Dur

Parmi les plugins les plus efficaces et les plus conviviaux pour créer des algorithmes d'apprentissage en profondeur se trouve un cadre neuronal artificiel élevé basé sur Python appelé Keras, qui serait construit au-dessus de cadres d'apprentissage en profondeur bien connus comme TensorFlow ou CNTK. Pour permettre une exploration plus rapide en utilisant des réseaux de neurones plus profonds, il est conçu de manière conviviale, extensible et adaptable. Il gère les réseaux Feedforward et rétractables séparément, ainsi qu'en combinaison. Il utilise le package Backend pour traiter les petites opérations car il est incapable de les gérer. Le déploiement de Keras, les principes fondamentaux de l'apprentissage en profondeur, les structures Keras, la superposition Keras, les packages Keras et la programmation en temps réel seront abordés dans cette leçon.

Configurer Keras sous Linux

Étape 01 : Mettre à jour le système

Avant d'avoir la démonstration complète de l'utilisation de la bibliothèque 'Keras' de Python, nous devons mettre à jour entièrement notre machine Linux pour faciliter les installations ultérieures. Pour cela, nous devons ouvrir rapidement l'application 'console' à partir des applications intégrées du système. Dans la zone de requête particulière, nous avons ajouté la requête 'mise à jour' de Linux avec l'utilitaire 'apt' et le privilège 'sudo' pour mettre à jour rapidement le système dont nous disposons. Il a exigé notre mot de passe d'utilisateur pour continuer ce processus afin que notre système puisse être mis à jour correctement.

Étape 02 : Installer Python et Pip

Pour l'utilisation de Deep Learning via Keras et TensorFlow, nous devons avoir configuré la dernière version de Python sur notre machine. Par conséquent, nous commençons à installer le package mis à jour de Python avec son utilitaire 'pip' nécessaire sur notre système. Pour cela, nous devons à nouveau utiliser l'utilitaire 'apt' du système Linux Ubuntu 20.04 dans la requête 'install' sur le shell suivi des noms des packages à installer, c'est-à-dire Python3 et Python3-pip. Lors de l'exécution de cette simple requête sur la zone de la console, le système commencera à installer et à configurer les deux packages dans notre système.

D'autre part, si votre système dispose d'une ancienne version de l'utilitaire 'pip' pour Python, vous devez le mettre à jour avant de continuer.

Après la configuration réussie de Python et de son utilitaire 'pip', il est temps de mettre à niveau les outils de configuration pour Python afin d'éviter tout problème dans un avenir proche. Par conséquent, nous avons essayé la requête d'installation avec l'utilitaire 'pip3' et l'option -upgrade pour installer la mise à niveau des outils de configuration, c'est-à-dire des outils de configuration. Il demande le mot de passe actuel que nous avons pour notre système, et nous l'avons ajouté.

Étape 03 : Installez TensorFlow

Pour la construction d'apprentissage automatique et de modèles neuronaux supervisés, TensorFlow est le package mathématique symbolique le plus connu. Après avoir parcouru les installations, nous avons exécuté la même requête d'installation 'pip3' suivie du nom du package 'Tensorflow'.

D'autres utilitaires liés à TensorFlow doivent être entièrement installés sur le système. Ces utilitaires seront installés avec TensorFlow, et cela peut prendre jusqu'à 10 minutes ou plus.

Étape 04 : Installer les packages essentiels

Après la configuration fructueuse de TensorFlow dans le système Ubuntu 20.04, nous devons également configurer certains packages de construction ainsi que d'autres utilitaires tels que 'git' et 'cmake'. En essayant le même outil 'apt', nous avons installé de nombreux packages nécessaires, comme indiqué ci-dessous :

Cette étape prend notre plus grande attention en confirmant cette installation. Appuyez sur 'y' et continuez.

Étape 05 : Créer un environnement virtuel

Après les installations nécessaires, il est temps de créer un environnement virtuel. Il faut donc utiliser l'utilitaire Python3 avec l'option « -m » pour créer l'environnement virtuel « kerasenv » via la variable « venv ». La requête 'ls' indique que l'environnement est créé.

Maintenant, nous devons nous déplacer dans l'environnement virtuel du dossier Keras. Ainsi, nous avons utilisé l'instruction 'cd' avec le nom d'un dossier d'environnement virtuel. Après cela, nous nous sommes déplacés dans le dossier 'bin' de cet environnement virtuel et avons répertorié son sous-dossier. Pour activer cet environnement Python, nous avons essayé l'instruction 'source' dans sa zone de requête avec le fichier 'activate'. L'environnement virtuel est activé avec le nom 'kerasenv'.

Étape 06 : Installer les bibliothèques Python

Après avoir configuré l'environnement virtuel Python avec succès, vous devez installer toutes les bibliothèques Python requises avant l'installation de Keras. Par conséquent, nous avons d'abord installé la bibliothèque de panda dans le même environnement virtuel en utilisant le package 'pip' de Python.

Le système commencera à le configurer dans l'environnement virtuel de Python, comme indiqué dans l'image :

Après avoir installé la bibliothèque des pandas, essayez d'installer la bibliothèque NumPy en utilisant la méthode suivante :

De manière très similaire, installez la bibliothèque scipy de Python dans le même environnement.

Maintenant, installez la bibliothèque matplotlib de Python dans l'environnement.

Python utilise des algorithmes de clustering et de régression dans l'apprentissage automatique pour réaliser des modèles de réseaux neuronaux. Pour cela, il dispose de la bibliothèque sci-kit learn que nous installons avec l'utilitaire 'pip' ainsi que l'option '-u' pour configurer également les packages requis.

Le traitement de l'installation de la bibliothèque scikit a été illustré ci-dessous :

Pour la visualisation en deep learning, nous avons besoin que la librairie seaborn de Python soit installée. Par conséquent, nous l'avons installé dans le même environnement avec la requête 'install'.

Étape 07 : Installer la bibliothèque Keras

Après l'installation de toutes les bibliothèques préalables nécessaires de Python, nous pouvons enfin installer Keras dans l'environnement virtuel de Python. L'utilitaire 'pip' sera utilisé à cette fin dans notre requête 'installer' avec le nom du module, c'est-à-dire 'Keras'. Si le système indique que son exigence est déjà satisfaite, cela signifie qu'il est déjà installé et configuré.

S'il n'est pas déjà installé, cette requête commencera à le télécharger et à le configurer dans l'environnement virtuel sans délai d'une seconde et le traitement s'affichera, comme ci-dessous :

Après la configuration complète et l'installation de la bibliothèque 'Keras' sur l'environnement virtuel, il est temps d'afficher toutes les informations la concernant sur le shell via la requête 'pip show'. L'exécution de cette requête 'show' a présenté la version de Keras installée dans notre environnement virtuel de Python, son nom, son résumé, sa page d'accueil Web, l'auteur, l'e-mail de l'auteur, la licence, l'emplacement qu'il prend sur notre système, et bien d'autres plus comme présenté ci-dessous:

Après les installations les plus fines des bibliothèques Keras et TensorFlow de Python, nous devons quitter l'environnement virtuel. Pour cela, essayez la requête 'désactiver' sur le shell et quittez.

Étape 08 : Installer Anaconda Cloud

Python a un nuage nommé 'Anaconda' qui est nécessaire pour créer des exemples de réseaux de neurones en Python. Par conséquent, nous avons téléchargé son fichier d'exécution sur notre système.

Ce fichier réside dans le dossier de départ actuel de la machine Linux conformément à la requête 'ls'. Vous devez d'abord vous assurer qu'il s'agit de la somme de contrôle, c'est-à-dire si elle est entièrement correcte ou non via la requête sha256sum.

Après cela, nous devons installer le fichier Bash téléchargé d'anaconda dans notre système en utilisant l'instruction 'Bash' et le nom du fichier sur la même console. Il nous a demandé de revoir le contrat de licence avant l'installation. Nous avons donc appuyé sur 'Entrée' pour continuer.

Après avoir parcouru son contrat de licence, il nous demande d'appuyer sur 'oui' si nous sommes d'accord avec les termes. Vous devez appuyer sur Entrée pour continuer l'installation au même endroit ou écrire le chemin vers le répertoire où vous souhaitez l'installer. Sinon, utilisez 'Ctrl-c' pour annuler l'installation.

Il affichera la longue liste de packages qui seront installés dans ce processus. Après l'exécution d'une transaction, il commencera à installer les packages.

Après un certain temps, l'anaconda a été installé avec succès avec ses packages supplémentaires.

Vous devez exécuter le fichier 'activate' à partir du dossier anaconda via la requête 'source' en tant que racine.

Essayez de lancer le navigateur anaconda en utilisant la requête suivante.

Pour créer et travailler sur le nouvel environnement conda, essayez l'instruction 'conda create' avec l'option name suivie du nom du nouvel environnement, c'est-à-dire PyCPU.

Ce processus nécessite notre confirmation sur la création du nouvel environnement. Appuyez sur 'y'.

Pour activer et exécuter l'environnement conda nouvellement créé, utilisez la requête 'conda activate' avec le nom de votre nouvel environnement, c'est-à-dire que l'environnement PyCPU est maintenant activé.

Étape 09 : Installez Spyder IDE

L'IDE Spyder doit être installé dans cet environnement pour l'exécution des programmes Python. Pour cela, nous avons essayé la requête d'installation conda sur le shell d'environnement PyCPU avec le mot-clé 'spyder'.

Appuyez sur 'y' pour continuer l'installation de Spyder.

Étape 10 : Installer la bibliothèque Pandas et Keras

Après l'installation de Spyder, installez la bibliothèque panda de Python dans un environnement anaconda en utilisant la requête d'installation conda avec l'option –c.

Encore une fois, appuyez sur le bouton 'y' pour continuer.

Après la configuration réussie de pandas, installez la bibliothèque Keras avec la même requête.

Continuez après avoir cliqué sur le bouton 'y'.

Vous pouvez lancer l'IDE Spyder dans la console de l'environnement actuel anaconda comme suit :

L'IDE Spyder se prépare à être lancé.

Le dossier caché '.keras' a été localisé dans le répertoire de base. Affichez-le et ouvrez son fichier 'keras.json' pour y ajouter les configurations suivantes.

Configurer Keras et TensorFlow sous Windows

Pour configurer Keras et TensorFlow dans un environnement Windows, vous devez vous assurer que le langage Python ainsi que sa bibliothèque 'pip' et Anaconda Navigator y sont déjà configurés. Après l'avoir configuré, vous devriez l'ouvrir à partir de votre zone de recherche et vous déplacer dans l'onglet 'environnements'. Dans cet onglet, vous trouverez le nom de l'environnement dans lequel vous travaillez actuellement, c'est-à-dire base. Dans la zone ci-dessous, vous trouverez l'onglet suivant. Appuyez sur l'option 'créer'.

Ici, vous devez créer un nouveau nom d'environnement 'TensorFlow', c'est-à-dire que vous êtes actuellement dans l'environnement de base. Sélectionnez la dernière version de Python à utiliser et appuyez sur le bouton 'Créer' pour continuer.

Vous verrez que l'environnement a commencé à se charger.

Après un certain temps, l'environnement TensorFlow est entièrement installé.

Depuis sa zone la plus à gauche, vous pouvez voir toutes les bibliothèques et modules installés et disponibles pour Python, comme présenté ci-dessous :

Maintenant, nous devons installer la bibliothèque backend TensorFlow de Python en utilisant cette zone. Dans la barre de recherche, écrivez 'TensorFlow' et marquez le même package de cas dans la liste affichée pour l'installer. Appuyez sur le bouton 'Appliquer' pour procéder à l'installation de TensorFlow avec ses sous-modules comme 'Keras'.

Il a commencé à fonctionner et à configurer le TensorFlow sur notre environnement Anaconda.

Pendant l'installation, il affichera la liste des sous-paquets qui vont être installés sur l'environnement Anaconda. Appuyez sur le bouton 'Appliquer' et attendez un moment jusqu'à ce qu'il soit terminé.

Au bout d'un moment, vous retrouverez tous les packages installés dans la même zone de modules. Vous pouvez voir que la bibliothèque Keras a été installée avec d'autres packages et nous n'avons pas à l'installer maintenant.

Dans la barre de recherche Windows, recherchez le mot-clé 'Jupyter'. L'application nommée 'Jupyter Notebook (TensorFlow)' serait affichée avec d'autres. Appuyez dessus pour lancer le jupyter Notebook avec le backend TensorFlow activé. Créez un nouveau fichier Python et commencez à travailler.

Apprentissage en profondeur via dur

L'apprentissage en profondeur comprend une analyse couche par couche de l'apport, chaque couche extrayant progressivement des détails de niveau avancé de l'entrée. Un cadre complet est fourni par Keras pour former toute sorte de réseau de neurones. À la fois créatif et incroyablement simple à comprendre, Keras. Il permet des modèles de réseaux de neurones allant du plus naïf au complexe le plus grand et le plus suprême.

Réseau de neurones artificiels (ANN)

La méthodologie 'Réseau de neurones artificiels' (ANN) semble être la méthode d'apprentissage en profondeur la plus utilisée et la plus fondamentale. Ils s'inspirent de l'esprit humain, le composant naturel le plus compliqué de notre corps, qui leur sert de modèle. Plus de 90 milliards de cellules microscopiques appelées « neurones » composent le cerveau d'un individu. Les axones et les dendrites sont des types de fibres nerveuses qui relient les neurones entre eux. La fonction principale d'un axone est d'envoyer des données d'un neurone lié à l'autre. Pour plus d'informations, veuillez effectuer une recherche à partir du moteur de recherche Google.

Architecture de Keras

L'architecture de l'API Keras a été classée en trois parties principales énumérées ci-dessous. Prenons une apparence à chacun distinctement.

• Modèle
• Couche
• Modules de base

Modèle dur

Le modèle Keras comprend exactement deux types, c'est-à-dire une API séquentielle et fonctionnelle.

Modèle séquentiel

Fondamentalement, un modèle séquentiel est une compilation chronologique de Keras Layers. Le modèle séquentiel simple et simpliste peut décrire presque tous les réseaux de neurones actuellement utilisés. Un modèle personnalisé peut être créé à l'aide de la classe Model révélée par le modèle séquentiel. L'approche de sous-classement peut être utilisée pour construire notre propre modèle sophistiqué. La démonstration du modèle séquentiel a été présentée ci-dessous.

Ajouter des calques

Le script a été lancé à partir de l'importation du mode séquentiel via le keras.models et l'autre ligne a créé un modèle séquentiel. Après cela, l'importation de la couche dense crée une couche d'entrée et ajoute une couche d'entrée à un modèle. La couche dense cachée a été créée et ajoutée au modèle et la même chose a été effectuée pour la couche dense de sortie.

Accéder au modèle

Vous pouvez obtenir des informations sur les couches de votre modèle, les données d'entrée qu'il a utilisées et ses données de sortie. La fonction model.layers permet d'accéder à tous les calques. Le model.inputs afficherait les tenseurs d'entrée et model.output afficherait les tenseurs de sortie.

Sérialiser le modèle

Il est facile de retourner le modèle utilisé dans le script en tant qu'objet ou JSON. Par exemple, la fonction get_config() produit le modèle en tant qu'entité/objet. La fonction from_config() crée un nouveau modèle en utilisant l'objet comme valeur paramétrique.

Vous pouvez également modifier votre modèle en JSON à l'aide de la fonction to_json().

Résumé du modèle

Pour obtenir le résumé complet des couches utilisées dans le modèle ainsi que des informations supplémentaires, appelez la fonction summary().

Former et prédire le modèle

Pour former et prédire, nous devrions utiliser la fonction de compilation, la fonction d'ajustement, l'évaluation de la fonction et la fonction de prédiction à cet égard.

Couches dures

Chaque couche d'entrée, cachée et de rendement dans le modèle suggéré de réseaux de neurones correspond à une couche Keras différente dans le modèle réel. Tout réseau de neurones sophistiqué peut être rapidement développé en utilisant de nombreuses couches prédéfinies de la bibliothèque Keras. Nous avons différentes couches Keras, c'est-à-dire des couches centrales, des couches de regroupement, des couches récurrentes et des couches de convolution. Vous pouvez les étudier en cherchant sur le web. Les deux premières lignes ont importé le mode séquentiel, la couche dense, l'activation et la suppression.

Nous avons essayé l'API Sequential() pour créer un modèle séquentiel d'abandon. En abandonnant le modèle d'activation 'relu', nous avons créé une couche dense via l'API 'Dense'. Pour répondre au sur-ajustement de la couche dense, nous avons utilisé l'API Dropout (), c'est-à-dire la superposition de suppression via la fonction dropout (). Après cela, nous avons utilisé ici une couche plus dense avec le modèle d'activation 'relu'. Pour gérer les couches denses dues à un ajustement excessif, nous devons utiliser des couches Dropout. Au final, nous avons largué nos dernières couches denses en utilisant le modèle d'activation de type 'softmax'.

Avez-vous déjà effectué des couches pendant la cuisson ? Si tel est le cas, ce concept ne vous sera pas difficile à comprendre. Le résultat d'un niveau servira de données d'entrée pour la couche suivante. Voici les éléments de base nécessaires pour créer une toute nouvelle couche :

• Forme des données d'entrée
• Nombre total de neurones/unités dans une couche
• Initialiseurs
• Régularisateurs
• Contraintes
• Activations

Forme des données d'entrée

Dans le langage Python, chaque type d'entrée a été converti en un tableau d'entiers, puis ajouté au modèle d'algorithme. Dans Python, nous devons spécifier la forme d'entrée pour obtenir la sortie selon nos besoins. Dans les exemples suivants, nous avons spécifié la forme d'entrée (3,3), c'est-à-dire 3 lignes et 3 colonnes. La sortie affiche la matrice.

Initialiseurs

Le module d'initialisation de Keras Layers nous fournit de nombreuses fonctions pour spécifier un poids spécifique pour les données d'entrée. Par exemple, la fonction zeros() spécifie 0 pour tous, les ones() spécifieraient pour tous, et la fonction constant() spécifiera une valeur constante spécifiée ajoutée par un utilisateur pour tous et plus. Pour une meilleure compréhension, nous avons utilisé la fonction identity() pour générer une matrice d'identité. Le reste des fonctions peut également être recherché à partir du moteur de recherche.

Contraintes

Il existe différentes fonctions de contrainte disponibles pour appliquer des contraintes sur le paramètre 'poids' de la couche, c'est-à-dire non négatif, norme unitaire, norme max, norme minmax et bien d'autres. Dans l'illustration suivante, nous avons appliqué la norme de contrainte inférieure ou égale au poids. Le paramètre 'max_value' est la borne supérieure de la contrainte à appliquer et l'axe est la dimension sur laquelle la contrainte serait appliquée, c'est-à-dire la dimension 1.

Régularisateurs

Tout au long de l'optimisation, il impose diverses charges sur la propriété de la couche. Il a également proposé certaines fonctions pour ce faire, à savoir le régularisateur L1, le régularisateur L2 et le régularisateur 'LI et L2'. Voici l'illustration la plus simple de la fonction de régularisation L1 :

Activations

Une fonction unique appelée fonction d'activation est utilisée pour déterminer si un neurone particulier est actif ou non. La fonction d'activation transforme les données entrantes de manière complexe, ce qui aide les neurones à étudier plus efficacement. Voici plusieurs méthodes d'activation présentées dans les exemples fournis ci-dessous :

Modules durs

Comme nous le savons, les modules de programmation contiennent généralement des fonctions, des classes et des variables à utiliser à des fins différentes et spécifiques. Juste comme ça, la bibliothèque Keras de Python contient de nombreux modules. Vous pouvez obtenir toutes les connaissances requises sur les modules Keras sur le Web.

Backend

L'un de ses modules les plus connus et les plus utilisés est le module 'Backend' qui a été conçu pour utiliser les bibliothèques backend de Python comme TensorFlow et Theano. En utilisant le module backend, nous pouvons utiliser autant de fonctions backend que possible à partir de la bibliothèque TensorFlow et Theano. Pour utiliser le module de bibliothèque backend, nous devons spécifier la bibliothèque backend à utiliser dans le fichier de configuration « keras.json », que nous avons créé dans le dossier caché .keras. Par défaut, le backend a été spécifié comme 'TensorFlow', mais vous pouvez également le changer pour un autre, c'est-à-dire Theano ou CNTK.

Dans notre exemple, nous utiliserons la bibliothèque TensorFlow comme backend. Pour charger les configurations du backend depuis le fichier keras.json du dossier racine « keras », utilisez :

• de keras importer le backend en tant que k

Après avoir importé avec succès le backend à partir du fichier keras.json, il est temps d'obtenir les informations du backend en utilisant la variable 'k' avec la variable à récupérer. Tout d'abord, nous avons récupéré le nom d'un backend que nous avons utilisé et déjà importé à l'aide de la fonction 'backend()'. Il renvoie le 'Tensorflow' comme valeur principale. Pour obtenir la valeur float du backend, nous avons appelé la fonction floatx() via l'objet variable 'k' de Keras. Cela montre que nous avons utilisé la valeur float32.

Pour obtenir le format des données d'image, utilisez la fonction image_Data_format() avec la variable 'k'. En l'utilisant, cela montre que notre backend utilise le format de données d'image 'channels_last'. Pour obtenir la puissance de l'exposant pour le backend, appelez la fonction epsilon() avec la variable 'k'. Il renvoie que le backend utilisera la puissance exponentielle de '07'. Il s'agit de la récupération des informations backend.

Fonction Get_uid()

Il est temps de jeter un œil à certaines fonctions backend de TensorFlow pour comprendre ses fonctionnalités. L'une de ses fonctions backend les plus utilisées 'la fonction get_uid () qui est utilisée pour identifier le graphique par défaut que nous avons utilisé. L'utiliser avec le paramètre prefix = '' renverrait '1', c'est-à-dire selon l'utilisation. Encore une fois, l'utiliser renverrait '2' car nous l'avons appelé à nouveau et la valeur du graphique a été incrémentée. Après avoir utilisé la fonction 'reset_uids', la valeur de l'ID utilisateur du graphique serait réinitialisée à 0. Par conséquent, l'utilisation à nouveau de la fonction get_uid() l'incrémenterait de 1.

Fonction Placeholder()

Le tenseur a utilisé la fonction placeholder() pour contenir différentes formes dimensionnelles. Par exemple, dans l'illustration suivante, nous l'avons utilisé pour maintenir l'image 3D en tenseur via la variable Keras 'k' et l'enregistrer dans une autre variable 'd'. La sortie de la variable 'd' affiche les propriétés d'une forme utilisée dans l'espace réservé.

La fonction « int_shape() » permet d'afficher la forme d'une valeur enregistrée dans l'espace réservé « d ».

Fonction Point()

Avez-vous déjà multiplié deux vecteurs ? Si c'est le cas, il ne vous sera pas difficile de multiplier deux tenseurs. Pour cela, la bibliothèque backend a proposé la fonction 'dot'. Tout d'abord, pour contenir les deux formes différentes, nous avons utilisé les valeurs de forme dans la fonction placeholder() dans les 2 premières lignes pour créer deux supports 'x' et 'y'. La fonction point () a pris les supports 'x' et 'y' pour multiplier les deux tenseurs et enregistrer le résultat dans une autre variable 'z'. Lors de l'utilisation du tenseur 'z' pour l'impression, il affiche la forme du tenseur résultant multiplié (1, 5) sur l'écran.

Fonction Uns()

La fonction ones() du module backend est connue pour initialiser toutes les valeurs d'une forme particulière à 1. Par exemple, nous avons utilisé la fonction ones() sur la forme du tenseur (3,3) et enregistré le résultat dans la variable 'v'. La fonction eval() est rejetée ici pour évaluer la valeur d'une variable 'v' et l'afficher dans l'environnement Python. En retour, il a converti la forme (3,3) en une matrice matricielle de tous avec le type de données float32.

Fonction batch_dot()

Le lot de tenseurs spécifierait le nombre total d'échantillons à trier avant de mettre à jour un modèle. La fonction batch_dot() du backend TensorFlow est principalement utilisée pour connaître le résultat de la multiplication de deux données de lot différentes. Par conséquent, nous avons créé deux variables tensorielles v1 et v2 et utilisé la fonction Input() pour les enregistrer dans v1 et v2 en entrée. Après cela, nous avons essayé la fonction batch_dot() sur les deux variables tensorielles, v1 et v2, et la valeur résultante serait enregistrée dans une autre variable 'v3'. En imprimant la variable v3, nous avons trouvé la forme résultante (2,2) en retour.

Fonction variable

Si vous avez déjà travaillé sur un autre langage, vous avez peut-être initialisé de nombreuses variables avec ou sans le mot-clé « var ». Plusieurs fois, vous avez peut-être initialisé les variables avec leurs types de données comme un entier, une chaîne ou un caractère. Dans la bibliothèque Python Keras, nous pouvons créer n'importe quelle variable à l'aide de la fonction variable() sur certaines données tensorielles sous forme d'échantillons.

Dans l'image suivante, nous avons créé une variable 'd' en ajoutant les deux exemples de données de liste dans une fonction variable() avec l'objet Keras 'k'. Après avoir ajouté cette variable, nous avons appelé la fonction transpose () sur cette variable 'd' pour connaître la transposition d'un échantillon de données en son sein via l'objet Keras 'k'. La transposition résultante serait enregistrée dans une variable 'val'. L'instruction print du langage Python a été utilisée ici pour imprimer la valeur de la variable résultante 'val'. L'instruction d'impression a affiché le choix de la fonction que nous avons appliquée à la variable 'd' et le nombre total d'éléments dans chaque liste.

Après cela, nous avons essayé la fonction 'eval' sur la variable 'val' pour obtenir la transposition des échantillons ajoutés à la variable 'd' et la fonction d'impression l'affichait. Vous pouvez voir la transposition de deux listes dans la sortie.

L'illustration de code précédente a été réalisée en utilisant de simples fonctions Python sans importer de bibliothèque Python particulière. La 'transposition' de deux ensembles de données peut être trouvée à l'aide des tableaux NumPy. Pour cela, nous devons importer la bibliothèque NumPy en tant que 'n' au début. Le format de base est le même, mais nous devons initialiser l'ensemble de données de forme avec le mot-clé 'array' au lieu d'utiliser le mot-clé 'variable'. L'exemple de tableau NumPy doit être conservé dans la variable 'd'. Le même objet NumPy « n » est utilisé pour appeler la fonction transpose() sur la variable « d » et enregistrer son résultat dans la variable « val ».

L'instruction print a appelé la variable 'val' pour afficher son tenseur de transposition. Vous pouvez voir, pour afficher la valeur transposée résultante de la variable 'val', nous n'avons pas besoin de la fonction 'eval' ici. Maintenant, nous avons utilisé la fonction variable avec l'argument 'd' et enregistré le résultat dans la variable 'z'. Après avoir essayé l'instruction d'impression en y ajoutant la valeur d'argument 'z', elle a affiché la sortie dans le même format précédent que nous avons essayé dans l'exemple de variable ci-dessus.

Fonction Is_sparse()

Le mot 'épars' dans tenseur est utilisé pour un tenseur clairsemé contenant des entrées avec des zéros principalement. Dans cet exemple, nous utiliserons la fonction is_sparse() du module backend pour vérifier si le tenseur a la plupart des zéros ou non.

Tout d'abord, nous avons appelé la fonction placeholder() pour conserver la forme du tenseur (3,3) avec l'argument Sparse défini sur true. Cette valeur d'espace réservé serait conservée au 'x' mutable et affichée. La sortie a affiché les informations concernant la variable d'espace réservé 'x'.

Par exemple, son type de données, sa forme et sa fonction lui sont appliqués. Après cela, nous avons essayé l'instruction print une fois de plus en appelant la fonction is_Sparse() qu'elle contient. Cette fonction a pris la variable 'x' comme argument pour afficher si le tenseur 'x' est clairsemé ou non. La sortie affiche 'vrai'.

Fonction To_dense()

On dit que le tenseur dense est celui qui a utilisé le bloc chronologique de mémoire pour stocker les informations de manière adjacente et représenter également les valeurs des informations. La fonction 'to_dense()' du module backend nous permet de convertir le tenseur creux en un tenseur dense. Par conséquent, nous prenons la même fonction d'espace réservé pour ajouter le tenseur à la variable 'x' et ce tenseur a été défini sur 'épars'.

La fonction 'to_dense()' est appliquée à la variable de tenseur dense 'x', c'est-à-dire pour la convertir en un tenseur dense et l'enregistrer dans une autre variable 'res'. Maintenant, le 'res' est un tenseur dense lui-même. L'instruction print a été rejetée pour imprimer la variable 'res'. L'utilisation d'instructions d'impression pour la variable 'res' affichait les informations concernant la variable convertie 'res', c'est-à-dire convertie avec succès de clairsemé en dense et bien plus encore.

Ensuite, une autre fonction d'impression est appelée en utilisant la fonction is_sparse() pour vérifier si la variable 'res' est clairsemée ou non. La sortie a montré que la variable 'res' n'est pas clairsemée, c'est-à-dire que nous l'avons déjà convertie en un tenseur 'dense'.

Fonction Random_uniform_variable()

La fonction random_uniform_variable() du module backend Keras est spécialement conçue pour l'initialisation d'un tenseur via la distribution uniforme. Il faut un total de trois arguments. Le tout premier argument 'forme' est utilisé pour définir les lignes et les colonnes de la forme dans le formulaire tuple. Si vous avez fait des mathématiques, vous avez peut-être appris le concept de moyenne et d'écart-type.

Dans la méthode random_uniform_variable(), les deux arguments suivants sont la moyenne et l'écart type par rapport à une distribution uniforme. Dans cette illustration, nous avons initialisé deux tenseurs 'x' et 'y' en utilisant la distribution uniforme standard via la fonction random_uniform_variable(). Les deux tenseurs contiennent des formats de forme différents, c'est-à-dire des lignes et des colonnes avec la même moyenne et l'écart type, c'est-à-dire bas = 0 et haut = 1.

Après cela, nous rejetons la fonction 'point' en y prenant les tenseurs 'x' et 'y' pour la multiplication. Le résultat de cette multiplication serait enregistré dans la variable 'z'. Au final, int_shape() est indispensable pour afficher la forme d'un tenseur résultant 'z'. La sortie affiche le tenseur (2,2).

Utilitaires

Si vous souhaitez utiliser certaines des fonctions très utiles du concept d'apprentissage en profondeur de Python, vous devez utiliser le module utils de la bibliothèque Keras dans vos scripts. Par exemple, si vous souhaitez afficher vos données au format HDF5Matrix, vous devez importer la classe HDF5Matrix et utiliser sa fonction HDF5Matrix dans le script.

Fonction To_categorical()

Cette fonction vous permet de modifier un vecteur de classe en une matrice, c'est-à-dire une matrice de classe binaire. Disons que nous avons importé la fonction to_categorical() du module utils et initialisé un vecteur 'A'. Le vecteur 'A' a été passé à la fonction to_categorical(). La matrice binaire pour ce vecteur de classe 'A' a été affichée.

fonction print_summary()

Pour imprimer le résumé d'un modèle que nous avons lancé dans notre environnement, la fonction print_summary a été utilisée.

fonction plot_model()

La fonction plot_model() signifie le modèle dans un format de point et vous permet de l'enregistrer dans un document.

Conclusion

Pour résumer, nous pouvons dire que le langage Python est un langage nécessaire pour l'ère d'aujourd'hui car tout va vite et la technologie a évolué à une vitesse folle. Tout au long de ce guide d'apprentissage, nous avons été à la hauteur de l'utilisation de la bibliothèque Keras de Python dans l'apprentissage en profondeur et les réseaux de neurones artificiels. Pour cela, nous avons également passé en revue l'importance et l'utilisation de sa bibliothèque backend 'TensorFlow' pour bien comprendre. De plus, nous avons discuté et expliqué chaque configuration requise pour configurer l'environnement Keras et Anaconda en Python dans le système d'exploitation Ubuntu 20.04 Linux. Après cela, nous avons discuté en détail des modèles, couches et modules Keras un par un, ainsi que de leurs fonctions les plus utilisées. Pour la démonstration du modèle Function API, veuillez consulter la documentation officielle.