TensorFlow - Guide rapide

TensorFlow est une bibliothèque de logiciels ou un framework, conçu par l'équipe Google pour mettre en œuvre des concepts d'apprentissage automatique et d'apprentissage en profondeur de la manière la plus simple. Il combine l'algèbre computationnelle des techniques d'optimisation pour un calcul facile de nombreuses expressions mathématiques.

Le site officiel de TensorFlow est mentionné ci-dessous -

www.tensorflow.org

Examinons maintenant les caractéristiques importantes suivantes de TensorFlow -

  • Il comprend une fonctionnalité qui définit, optimise et calcule facilement les expressions mathématiques à l'aide de tableaux multidimensionnels appelés tenseurs.

  • Il comprend un support de programmation des réseaux de neurones profonds et des techniques d'apprentissage automatique.

  • Il comprend une fonction de calcul hautement évolutive avec divers ensembles de données.

  • TensorFlow utilise le calcul GPU, automatisant la gestion. Il comprend également une fonctionnalité unique d'optimisation de la même mémoire et des données utilisées.

Pourquoi TensorFlow est-il si populaire?

TensorFlow est bien documenté et comprend de nombreuses bibliothèques d'apprentissage automatique. Il offre quelques fonctionnalités et méthodes importantes pour le même.

TensorFlow est également appelé un produit «Google». Il comprend une variété d'algorithmes d'apprentissage automatique et d'apprentissage en profondeur. TensorFlow peut entraîner et gérer des réseaux de neurones profonds pour la classification manuscrite des chiffres, la reconnaissance d'image, l'incorporation de mots et la création de divers modèles de séquence.

Pour installer TensorFlow, il est important que «Python» soit installé sur votre système. La version 3.4+ de Python est considérée comme la meilleure pour démarrer l'installation de TensorFlow.

Considérez les étapes suivantes pour installer TensorFlow dans le système d'exploitation Windows.

Step 1 - Vérifiez la version de Python en cours d'installation.

Step 2- Un utilisateur peut choisir n'importe quel mécanisme pour installer TensorFlow dans le système. Nous recommandons «pip» et «Anaconda». Pip est une commande utilisée pour exécuter et installer des modules en Python.

Avant d'installer TensorFlow, nous devons installer le framework Anaconda dans notre système.

Une fois l'installation réussie, enregistrez l'invite de commande via la commande «conda». L'exécution de la commande est affichée ci-dessous -

Step 3 - Exécutez la commande suivante pour initialiser l'installation de TensorFlow -

conda create --name tensorflow python = 3.5

Il télécharge les packages nécessaires à la configuration de TensorFlow.

Step 4 - Après une configuration environnementale réussie, il est important d'activer le module TensorFlow.

activate tensorflow

Step 5- Utilisez pip pour installer «Tensorflow» dans le système. La commande utilisée pour l'installation est mentionnée ci-dessous -

pip install tensorflow

Et,

pip install tensorflow-gpu

Une fois l'installation réussie, il est important de connaître l'exemple d'exécution du programme de TensorFlow.

L'exemple suivant nous aide à comprendre la création de programme de base «Hello World» dans TensorFlow.

Le code pour la première mise en œuvre du programme est mentionné ci-dessous -

>> activate tensorflow
>> python (activating python shell)
>> import tensorflow as tf
>> hello = tf.constant(‘Hello, Tensorflow!’)
>> sess = tf.Session()
>> print(sess.run(hello))

L'intelligence artificielle comprend le processus de simulation de l'intelligence humaine par des machines et des systèmes informatiques spéciaux. Les exemples d'intelligence artificielle incluent l'apprentissage, le raisonnement et l'autocorrection. Les applications de l'IA comprennent la reconnaissance vocale, les systèmes experts, la reconnaissance d'image et la vision industrielle.

L'apprentissage automatique est la branche de l'intelligence artificielle, qui traite des systèmes et des algorithmes capables d'apprendre de nouveaux modèles de données et de données.

Concentrons-nous sur le diagramme de Venn mentionné ci-dessous pour comprendre les concepts d'apprentissage automatique et d'apprentissage en profondeur.

L'apprentissage automatique comprend une section d'apprentissage automatique et l'apprentissage en profondeur fait partie de l'apprentissage automatique. La capacité du programme qui suit les concepts d'apprentissage automatique est d'améliorer ses performances des données observées. Le principal motif de la transformation des données est d'améliorer ses connaissances afin d'obtenir de meilleurs résultats à l'avenir, de fournir une sortie plus proche de la sortie souhaitée pour ce système particulier. L'apprentissage automatique comprend la «reconnaissance de formes» qui inclut la capacité de reconnaître les modèles dans les données.

Les modèles doivent être formés pour montrer la sortie de manière souhaitable.

L'apprentissage automatique peut être formé de deux manières différentes:

  • Formation supervisée
  • Formation non supervisée

Enseignement supervisé

L'apprentissage supervisé ou l'apprentissage supervisé comprend une procédure dans laquelle l'ensemble d'apprentissage est donné en entrée du système dans lequel chaque exemple est étiqueté avec une valeur de sortie souhaitée. La formation dans ce type est effectuée en utilisant la minimisation d'une fonction de perte particulière, qui représente l'erreur de sortie par rapport au système de sortie souhaité.

Une fois l'apprentissage terminé, la précision de chaque modèle est mesurée par rapport aux exemples disjoints de l'ensemble d'apprentissage, également appelé ensemble de validation.

Le meilleur exemple pour illustrer «l'apprentissage supervisé» est avec un tas de photos fournies avec des informations incluses. Ici, l'utilisateur peut entraîner un modèle à reconnaître de nouvelles photos.

Apprentissage non supervisé

Dans un apprentissage non supervisé ou une formation non supervisée, incluez des exemples de formation, qui ne sont pas étiquetés par le système auquel ils appartiennent. Le système recherche les données, qui partagent des caractéristiques communes, et les modifie en fonction des caractéristiques de connaissances internes. Ce type d'algorithmes d'apprentissage est essentiellement utilisé dans les problèmes de clustering.

Le meilleur exemple pour illustrer «l'apprentissage non supervisé» est avec un tas de photos sans informations incluses et un modèle de train d'utilisateurs avec classification et regroupement. Ce type d'algorithme de formation fonctionne avec des hypothèses car aucune information n'est donnée.

Il est important de comprendre les concepts mathématiques nécessaires à TensorFlow avant de créer l'application de base dans TensorFlow. Les mathématiques sont considérées comme le cœur de tout algorithme d'apprentissage automatique. C'est à l'aide des concepts de base des mathématiques, qu'une solution pour un algorithme d'apprentissage automatique spécifique est définie.

Vecteur

Un tableau de nombres, qui est soit continu soit discret, est défini comme un vecteur. Les algorithmes d'apprentissage automatique traitent des vecteurs de longueur fixe pour une meilleure génération de sortie.

Les algorithmes d'apprentissage automatique traitent des données multidimensionnelles, de sorte que les vecteurs jouent un rôle crucial.

La représentation picturale du modèle vectoriel est comme indiqué ci-dessous -

Scalaire

Scalar peut être défini comme un vecteur unidimensionnel. Les scalaires sont ceux qui n'incluent que la magnitude et aucune direction. Avec les scalaires, nous ne sommes préoccupés que par la magnitude.

Des exemples de scalaires incluent les paramètres de poids et de taille des enfants.

Matrice

La matrice peut être définie comme des tableaux multidimensionnels, qui sont organisés au format de lignes et de colonnes. La taille de la matrice est définie par la longueur de ligne et la longueur de colonne. La figure suivante montre la représentation de toute matrice spécifiée.

Considérons la matrice avec «m» lignes et «n» colonnes comme mentionné ci-dessus, la représentation matricielle sera spécifiée comme «m * n matrice» qui définit également la longueur de la matrice.

Calculs mathématiques

Dans cette section, nous allons découvrir les différents calculs mathématiques dans TensorFlow.

Ajout de matrices

L'ajout de deux ou plusieurs matrices est possible si les matrices sont de même dimension. L'addition implique l'ajout de chaque élément selon la position donnée.

Prenons l'exemple suivant pour comprendre comment fonctionne l'ajout de matrices -

$$ Exemple: A = \ begin {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} B = \ begin {bmatrix} 5 & 6 \\ 7 & 8 \ end {bmatrix} \: then \: A + B = \ begin {bmatrix} 1 + 5 & 2 + 6 \\ 3 + 7 & 4 + 8 \ end {bmatrix} = \ begin {bmatrix} 6 & 8 \\ 10 & 12 \ end {bmatrix} $$

Soustraction de matrices

La soustraction de matrices fonctionne de la même manière que l'addition de deux matrices. L'utilisateur peut soustraire deux matrices à condition que les dimensions soient égales.

$$ Exemple: A- \ begin {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} B- \ begin {bmatrix} 5 & 6 \\ 7 & 8 \ end {bmatrix} \: then \: AB - \ begin {bmatrix} 1-5 & 2-6 \\ 3-7 & 4-8 \ end {bmatrix} - \ begin {bmatrix} -4 & -4 \\ - 4 & -4 \ end {bmatrix} $$

Multiplication des matrices

Pour que deux matrices A m * n et B p * q soient multipliables, n devrait être égal à p. La matrice résultante est -

C m * q

$$ A = \ begin {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} B = \ begin {bmatrix} 5 & 6 \\ 7 & 8 \ end {bmatrix} $$

$$ c_ {11} = \ begin {bmatrix} 1 & 2 \ end {bmatrix} \ begin {bmatrix} 5 \\ 7 \ end {bmatrix} = 1 \ times5 + 2 \ times7 = 19 \: c_ {12} = \ begin {bmatrix} 1 & 2 \ end {bmatrix} \ begin {bmatrix} 6 \\ 8 \ end {bmatrix} = 1 \ times6 + 2 \ times8 = 22 $$

$$ c_ {21} = \ begin {bmatrix} 3 & 4 \ end {bmatrix} \ begin {bmatrix} 5 \\ 7 \ end {bmatrix} = 3 \ times5 + 4 \ times7 = 43 \: c_ {22} = \ begin {bmatrix} 3 & 4 \ end {bmatrix} \ begin {bmatrix} 6 \\ 8 \ end {bmatrix} = 3 \ times6 + 4 \ times8 = 50 $$

$$ C = \ begin {bmatrix} c_ {11} & c_ {12} \\ c_ {21} & c_ {22} \ end {bmatrix} = \ begin {bmatrix} 19 & 22 \\ 43 & 50 \ end {bmatrix} $$

Transposer la matrice

La transposée d'une matrice A, m * n est généralement représentée par AT (transpose) n * m et est obtenue en transposant les vecteurs colonnes en vecteurs lignes.

$$ Exemple: A = \ begin {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} \: then \: A ^ {T} \ begin {bmatrix} 1 & 3 \\ 2 & 4 \ end { bmatrix} $$

Produit scalaire de vecteurs

Tout vecteur de dimension n peut être représenté par une matrice v = R ^ n * 1.

$$ v_ {1} = \ begin {bmatrix} v_ {11} \\ v_ {12} \\\ cdot \\\ cdot \\\ cdot \\ v_ {1n} \ end {bmatrix} v_ {2} = \ begin {bmatrix} v_ {21} \\ v_ {22} \\\ cdot \\\ cdot \\\ cdot \\ v_ {2n} \ end {bmatrix} $$

Le produit scalaire de deux vecteurs est la somme du produit des composants correspondants - Composants de même dimension et peut être exprimé comme

$$ v_ {1} \ cdot v_ {2} = v_1 ^ Tv_ {2} = v_2 ^ Tv_ {1} = v_ {11} v_ {21} + v_ {12} v_ {22} + \ cdot \ cdot + v_ {1n} v_ {2n} = \ displaystyle \ sum \ limits_ {k = 1} ^ n v_ {1k} v_ {2k} $$

L'exemple de produit scalaire de vecteurs est mentionné ci-dessous -

$$ Exemple: v_ {1} = \ begin {bmatrix} 1 \\ 2 \\ 3 \ end {bmatrix} v_ {2} = \ begin {bmatrix} 3 \\ 5 \\ - 1 \ end {bmatrix} v_ {1} \ cdot v_ {2} = v_1 ^ Tv_ {2} = 1 \ times3 + 2 \ times5-3 \ times1 = 10 $$

L'intelligence artificielle est l'une des tendances les plus populaires de ces derniers temps. L'apprentissage automatique et l'apprentissage profond constituent l'intelligence artificielle. Le diagramme de Venn ci-dessous explique la relation entre l'apprentissage automatique et l'apprentissage en profondeur -

Apprentissage automatique

L'apprentissage automatique est l'art de faire en sorte que les ordinateurs agissent selon les algorithmes conçus et programmés. De nombreux chercheurs pensent que l'apprentissage automatique est le meilleur moyen de progresser vers l'IA au niveau humain. L'apprentissage automatique comprend les types de modèles suivants

  • Modèle d'apprentissage supervisé
  • Modèle d'apprentissage non supervisé

L'apprentissage en profondeur

L'apprentissage en profondeur est un sous-domaine de l'apprentissage automatique où les algorithmes concernés sont inspirés de la structure et de la fonction du cerveau appelées réseaux de neurones artificiels.

Toute la valeur actuelle de l'apprentissage en profondeur réside dans l'apprentissage supervisé ou l'apprentissage à partir de données et d'algorithmes étiquetés.

Chaque algorithme de l'apprentissage profond passe par le même processus. Il comprend une hiérarchie de transformation non linéaire de l'entrée qui peut être utilisée pour générer un modèle statistique en sortie.

Tenez compte des étapes suivantes qui définissent le processus d'apprentissage automatique

  • Identifie les ensembles de données pertinents et les prépare pour l'analyse.
  • Choisit le type d'algorithme à utiliser
  • Construit un modèle analytique basé sur l'algorithme utilisé.
  • Entraîne le modèle sur des ensembles de données de test, en le révisant si nécessaire.
  • Exécute le modèle pour générer des scores de test.

Différence entre l'apprentissage automatique et l'apprentissage profond

Dans cette section, nous découvrirons la différence entre le Machine Learning et le Deep Learning.

Quantité de données

L'apprentissage automatique fonctionne avec de grandes quantités de données. Il est également utile pour de petites quantités de données. Le Deep Learning, quant à lui, fonctionne efficacement si la quantité de données augmente rapidement. Le diagramme suivant montre le fonctionnement du machine learning et du deep learning avec la quantité de données -

Dépendances matérielles

Les algorithmes d'apprentissage en profondeur sont conçus pour dépendre fortement de machines haut de gamme contrairement aux algorithmes d'apprentissage automatique traditionnels. Les algorithmes d'apprentissage en profondeur effectuent un certain nombre d'opérations de multiplication matricielle, qui nécessitent une grande quantité de support matériel.

Ingénierie des fonctionnalités

L'ingénierie des fonctionnalités est le processus qui consiste à intégrer la connaissance du domaine dans des fonctionnalités spécifiées pour réduire la complexité des données et créer des modèles visibles pour les algorithmes d'apprentissage.

Exemple - Les modèles d'apprentissage automatique traditionnels se concentrent sur les pixels et d'autres attributs nécessaires au processus d'ingénierie des fonctionnalités. Les algorithmes d'apprentissage en profondeur se concentrent sur des fonctionnalités de haut niveau à partir de données. Il réduit la tâche de développement de l'extracteur de nouvelles fonctionnalités de chaque nouveau problème.

Approche de résolution de problèmes

Les algorithmes d'apprentissage automatique traditionnels suivent une procédure standard pour résoudre le problème. Il décompose le problème en plusieurs parties, résout chacune d'elles et les combine pour obtenir le résultat souhaité. L'apprentissage profond se concentre sur la résolution du problème de bout en bout au lieu de le diviser en divisions.

Temps d'exécution

Le temps d'exécution est le temps nécessaire pour entraîner un algorithme. L'apprentissage en profondeur nécessite beaucoup de temps pour s'entraîner car il comprend de nombreux paramètres, ce qui prend plus de temps que d'habitude. L'algorithme d'apprentissage automatique nécessite comparativement moins de temps d'exécution.

Interprétabilité

L'interprétabilité est le principal facteur de comparaison des algorithmes d'apprentissage automatique et d'apprentissage en profondeur. La raison principale est que l'apprentissage en profondeur fait encore l'objet d'une seconde réflexion avant son utilisation dans l'industrie.

Applications du Machine Learning et du Deep Learning

Dans cette section, nous découvrirons les différentes applications du Machine Learning et du Deep Learning.

  • Vision par ordinateur utilisée pour la reconnaissance faciale et la marque de présence par empreintes digitales ou l'identification du véhicule par plaque d'immatriculation.

  • Récupération d'informations à partir des moteurs de recherche comme la recherche de texte pour la recherche d'images.

  • Marketing automatisé par e-mail avec identification de la cible spécifiée.

  • Diagnostic médical des tumeurs cancéreuses ou identification des anomalies de toute maladie chronique.

  • Traitement du langage naturel pour des applications telles que le marquage de photos. Le meilleur exemple pour expliquer ce scénario est utilisé dans Facebook.

  • Publicité en ligne.

Tendances futures

  • Avec la tendance croissante à utiliser la science des données et l'apprentissage automatique dans l'industrie, il deviendra important pour chaque organisation d'inculquer l'apprentissage automatique dans leurs entreprises.

  • L'apprentissage en profondeur prend plus d'importance que l'apprentissage automatique. L'apprentissage en profondeur s'avère être l'une des meilleures techniques de performance de pointe.

  • L'apprentissage automatique et l'apprentissage en profondeur s'avéreront bénéfiques dans le domaine de la recherche et des universitaires.

Conclusion

Dans cet article, nous avons eu un aperçu de l'apprentissage automatique et de l'apprentissage profond avec des illustrations et des différences se concentrant également sur les tendances futures. De nombreuses applications d'IA utilisent principalement des algorithmes d'apprentissage automatique pour stimuler le libre-service, augmenter la productivité des agents et fiabiliser les flux de travail. Les algorithmes d'apprentissage automatique et d'apprentissage en profondeur offrent une perspective intéressante pour de nombreuses entreprises et leaders du secteur.

Dans ce chapitre, nous allons découvrir les bases de TensorFlow. Nous commencerons par comprendre la structure de données du tenseur.

Structure des données Tensor

Les tenseurs sont utilisés comme structures de données de base dans le langage TensorFlow. Les tenseurs représentent les arêtes de connexion dans tout organigramme appelé graphique de flux de données. Les tenseurs sont définis comme un tableau ou une liste multidimensionnelle.

Les tenseurs sont identifiés par les trois paramètres suivants -

Rang

L'unité de dimensionnalité décrite dans le tenseur est appelée rang. Il identifie le nombre de dimensions du tenseur. Un rang d'un tenseur peut être décrit comme l'ordre ou les n-dimensions d'un tenseur défini.

Forme

Le nombre de lignes et de colonnes définit ensemble la forme de Tensor.

Type

Type décrit le type de données affecté aux éléments de Tensor.

Un utilisateur doit prendre en compte les activités suivantes pour construire un Tensor -

  • Construire un tableau à n dimensions
  • Convertissez le tableau à n dimensions.

Différentes dimensions de TensorFlow

TensorFlow comprend différentes dimensions. Les dimensions sont décrites brièvement ci-dessous -

Tenseur unidimensionnel

Un tenseur dimensionnel est une structure de tableau normale qui comprend un ensemble de valeurs du même type de données.

Declaration

>>> import numpy as np
>>> tensor_1d = np.array([1.3, 1, 4.0, 23.99])
>>> print tensor_1d

L'implémentation avec la sortie est montrée dans la capture d'écran ci-dessous -

L'indexation des éléments est identique à celle des listes Python. Le premier élément commence par un index de 0; pour imprimer les valeurs via l'index, il vous suffit de mentionner le numéro d'index.

>>> print tensor_1d[0]
1.3
>>> print tensor_1d[2]
4.0

Tenseurs bidimensionnels

Des séquences de tableaux sont utilisées pour créer des «tenseurs bidimensionnels».

La création de tenseurs bidimensionnels est décrite ci-dessous -

Voici la syntaxe complète pour créer des tableaux à deux dimensions -

>>> import numpy as np
>>> tensor_2d = np.array([(1,2,3,4),(4,5,6,7),(8,9,10,11),(12,13,14,15)])
>>> print(tensor_2d)
[[ 1 2 3 4]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
>>>

Les éléments spécifiques des tenseurs bidimensionnels peuvent être suivis à l'aide du numéro de ligne et du numéro de colonne spécifiés sous forme de numéros d'index.

>>> tensor_2d[3][2]
14

Manipulation et manipulations des tenseurs

Dans cette section, nous en apprendrons davantage sur la gestion et les manipulations de Tensor.

Pour commencer, considérons le code suivant -

import tensorflow as tf
import numpy as np

matrix1 = np.array([(2,2,2),(2,2,2),(2,2,2)],dtype = 'int32')
matrix2 = np.array([(1,1,1),(1,1,1),(1,1,1)],dtype = 'int32')

print (matrix1)
print (matrix2)

matrix1 = tf.constant(matrix1)
matrix2 = tf.constant(matrix2)
matrix_product = tf.matmul(matrix1, matrix2)
matrix_sum = tf.add(matrix1,matrix2)
matrix_3 = np.array([(2,7,2),(1,4,2),(9,0,2)],dtype = 'float32')
print (matrix_3)

matrix_det = tf.matrix_determinant(matrix_3)
with tf.Session() as sess:
   result1 = sess.run(matrix_product)
   result2 = sess.run(matrix_sum)
   result3 = sess.run(matrix_det)

print (result1)
print (result2)
print (result3)

Output

Le code ci-dessus générera la sortie suivante -

Explication

Nous avons créé des tableaux multidimensionnels dans le code source ci-dessus. Maintenant, il est important de comprendre que nous avons créé un graphique et des sessions, qui gèrent les Tensors et génèrent la sortie appropriée. Avec l'aide du graphique, nous avons la sortie spécifiant les calculs mathématiques entre Tensors.

Après avoir compris les concepts d'apprentissage automatique, nous pouvons maintenant nous concentrer sur les concepts d'apprentissage profond. L'apprentissage en profondeur est une division de l'apprentissage automatique et est considéré comme une étape cruciale franchie par les chercheurs au cours des dernières décennies. Les exemples de mise en œuvre de l'apprentissage en profondeur incluent des applications telles que la reconnaissance d'image et la reconnaissance vocale.

Voici les deux types importants de réseaux de neurones profonds -

  • Réseaux de neurones convolutifs
  • Réseaux de neurones récurrents

Dans ce chapitre, nous nous concentrerons sur le CNN, les réseaux de neurones convolutifs.

Réseaux de neurones convolutifs

Les réseaux de neurones convolutifs sont conçus pour traiter les données à travers plusieurs couches de tableaux. Ce type de réseaux neuronaux est utilisé dans des applications telles que la reconnaissance d'image ou la reconnaissance faciale. La principale différence entre CNN et tout autre réseau de neurones ordinaire est que CNN prend les entrées sous forme de tableau bidimensionnel et opère directement sur les images plutôt que de se concentrer sur l'extraction de caractéristiques sur laquelle se concentrent d'autres réseaux de neurones.

L'approche dominante de CNN inclut des solutions aux problèmes de reconnaissance. Des entreprises de premier plan comme Google et Facebook ont ​​investi dans la recherche et le développement pour des projets de reconnaissance afin d'accélérer les activités.

Un réseau de neurones convolutifs utilise trois idées de base -

  • Champs respectifs locaux
  • Convolution
  • Pooling

Comprenons ces idées en détail.

CNN utilise des corrélations spatiales qui existent dans les données d'entrée. Chaque couche simultanée d'un réseau neuronal connecte certains neurones d'entrée. Cette région spécifique est appelée champ réceptif local. Le champ réceptif local se concentre sur les neurones cachés. Les neurones cachés traitent les données d'entrée à l'intérieur du champ mentionné sans réaliser les changements en dehors de la limite spécifique.

Voici une représentation schématique de la génération de champs respectifs locaux -

Si nous observons la représentation ci-dessus, chaque connexion apprend un poids du neurone caché avec une connexion associée avec le mouvement d'une couche à l'autre. Ici, les neurones individuels effectuent un changement de temps en temps. Ce processus est appelé «convolution».

Le mappage des connexions de la couche d'entrée à la carte d'entités cachées est défini comme des «pondérations partagées» et le biais inclus est appelé «biais partagé».

CNN ou réseaux de neurones convolutifs utilisent des couches de regroupement, qui sont les couches, positionnées immédiatement après la déclaration CNN. Il prend les entrées de l'utilisateur comme une carte des caractéristiques qui sort des réseaux convolutifs et prépare une carte des caractéristiques condensée. La mise en commun des couches aide à créer des couches avec des neurones des couches précédentes.

Implémentation TensorFlow de CNN

Dans cette section, nous découvrirons l'implémentation TensorFlow de CNN. Les étapes, qui nécessitent l'exécution et la dimension appropriée de l'ensemble du réseau, sont indiquées ci-dessous -

Step 1 - Incluez les modules nécessaires pour TensorFlow et les modules de jeu de données, nécessaires pour calculer le modèle CNN.

import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data

Step 2 - Déclarez une fonction appelée run_cnn(), qui comprend divers paramètres et variables d'optimisation avec déclaration d'espaces réservés de données. Ces variables d'optimisation déclareront le modèle d'apprentissage.

def run_cnn():
   mnist = input_data.read_data_sets("MNIST_data/", one_hot = True)
   learning_rate = 0.0001
   epochs = 10
   batch_size = 50

Step 3 - Dans cette étape, nous déclarerons les espaces réservés des données d'apprentissage avec les paramètres d'entrée - pour 28 x 28 pixels = 784. Il s'agit des données d'image aplaties qui sont tirées de mnist.train.nextbatch().

Nous pouvons remodeler le tenseur selon nos besoins. La première valeur (-1) indique à la fonction de façonner dynamiquement cette dimension en fonction de la quantité de données qui lui est transmise. Les deux dimensions moyennes sont réglées sur la taille de l'image (c'est-à-dire 28 x 28).

x = tf.placeholder(tf.float32, [None, 784])
x_shaped = tf.reshape(x, [-1, 28, 28, 1])
y = tf.placeholder(tf.float32, [None, 10])

Step 4 - Maintenant, il est important de créer des couches convolutives -

layer1 = create_new_conv_layer(x_shaped, 1, 32, [5, 5], [2, 2], name = 'layer1')
layer2 = create_new_conv_layer(layer1, 32, 64, [5, 5], [2, 2], name = 'layer2')

Step 5- Aplatissons la sortie prête pour l'étage de sortie entièrement connecté - après deux couches de mise en commun stride 2 avec les dimensions de 28 x 28, à la dimension de 14 x 14 ou minimum 7 x 7 x, coordonnées y, mais avec 64 canaux de sortie. Pour créer le calque entièrement connecté avec "dense", la nouvelle forme doit être [-1, 7 x 7 x 64]. Nous pouvons définir des poids et des valeurs de biais pour cette couche, puis l'activer avec ReLU.

flattened = tf.reshape(layer2, [-1, 7 * 7 * 64])

wd1 = tf.Variable(tf.truncated_normal([7 * 7 * 64, 1000], stddev = 0.03), name = 'wd1')
bd1 = tf.Variable(tf.truncated_normal([1000], stddev = 0.01), name = 'bd1')

dense_layer1 = tf.matmul(flattened, wd1) + bd1
dense_layer1 = tf.nn.relu(dense_layer1)

Step 6 - Une autre couche avec des activations softmax spécifiques avec l'optimiseur requis définit l'évaluation de la précision, ce qui rend la configuration de l'opérateur d'initialisation.

wd2 = tf.Variable(tf.truncated_normal([1000, 10], stddev = 0.03), name = 'wd2')
bd2 = tf.Variable(tf.truncated_normal([10], stddev = 0.01), name = 'bd2')

dense_layer2 = tf.matmul(dense_layer1, wd2) + bd2
y_ = tf.nn.softmax(dense_layer2)

cross_entropy = tf.reduce_mean(
   tf.nn.softmax_cross_entropy_with_logits(logits = dense_layer2, labels = y))

optimiser = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cross_entropy)

correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

init_op = tf.global_variables_initializer()

Step 7- Nous devons mettre en place des variables d'enregistrement. Cela ajoute un résumé pour stocker l'exactitude des données.

tf.summary.scalar('accuracy', accuracy)
   merged = tf.summary.merge_all()
   writer = tf.summary.FileWriter('E:\TensorFlowProject')
   
   with tf.Session() as sess:
      sess.run(init_op)
      total_batch = int(len(mnist.train.labels) / batch_size)
      
      for epoch in range(epochs):
         avg_cost = 0
      for i in range(total_batch):
         batch_x, batch_y = mnist.train.next_batch(batch_size = batch_size)
            _, c = sess.run([optimiser, cross_entropy], feed_dict = {
            x:batch_x, y: batch_y})
            avg_cost += c / total_batch
         test_acc = sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
            summary = sess.run(merged, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
         writer.add_summary(summary, epoch)

   print("\nTraining complete!")
   writer.add_graph(sess.graph)
   print(sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
      mnist.test.labels}))

def create_new_conv_layer(
   input_data, num_input_channels, num_filters,filter_shape, pool_shape, name):

   conv_filt_shape = [
      filter_shape[0], filter_shape[1], num_input_channels, num_filters]

   weights = tf.Variable(
      tf.truncated_normal(conv_filt_shape, stddev = 0.03), name = name+'_W')
   bias = tf.Variable(tf.truncated_normal([num_filters]), name = name+'_b')

#Out layer defines the output
   out_layer =
      tf.nn.conv2d(input_data, weights, [1, 1, 1, 1], padding = 'SAME')

   out_layer += bias
   out_layer = tf.nn.relu(out_layer)
   ksize = [1, pool_shape[0], pool_shape[1], 1]
   strides = [1, 2, 2, 1]
   out_layer = tf.nn.max_pool(
      out_layer, ksize = ksize, strides = strides, padding = 'SAME')

   return out_layer

if __name__ == "__main__":
run_cnn()

Voici la sortie générée par le code ci-dessus -

See @{tf.nn.softmax_cross_entropy_with_logits_v2}.

2018-09-19 17:22:58.802268: I
T:\src\github\tensorflow\tensorflow\core\platform\cpu_feature_guard.cc:140]
Your CPU supports instructions that this TensorFlow binary was not compiled to
use: AVX2

2018-09-19 17:25:41.522845: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.

2018-09-19 17:25:44.630941: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 501760000 exceeds 10% of system memory.

Epoch: 1 cost = 0.676 test accuracy: 0.940

2018-09-19 17:26:51.987554: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.

Les réseaux de neurones récurrents sont un type d'algorithme axé sur l'apprentissage en profondeur, qui suit une approche séquentielle. Dans les réseaux de neurones, nous supposons toujours que chaque entrée et sortie est indépendante de toutes les autres couches. Ces types de réseaux de neurones sont appelés récurrents car ils effectuent des calculs mathématiques de manière séquentielle.

Considérez les étapes suivantes pour former un réseau neuronal récurrent -

Step 1 - Saisissez un exemple spécifique à partir de l'ensemble de données.

Step 2 - Le réseau prendra un exemple et calculera certains calculs en utilisant des variables initialisées aléatoirement.

Step 3 - Un résultat prédit est ensuite calculé.

Step 4 - La comparaison du résultat réel généré avec la valeur attendue produira une erreur.

Step 5 - Pour tracer l'erreur, elle est propagée par le même chemin où les variables sont également ajustées.

Step 6 - Les étapes de 1 à 5 sont répétées jusqu'à ce que nous soyons sûrs que les variables déclarées pour obtenir la sortie sont définies correctement.

Step 7 - Une prédiction systématique est faite en appliquant ces variables pour obtenir une nouvelle entrée invisible.

L'approche schématique de la représentation des réseaux de neurones récurrents est décrite ci-dessous -

Implémentation récurrente de réseau neuronal avec TensorFlow

Dans cette section, nous allons apprendre comment implémenter un réseau de neurones récurrent avec TensorFlow.

Step 1 - TensorFlow comprend diverses bibliothèques pour une implémentation spécifique du module de réseau neuronal récurrent.

#Import necessary modules
from __future__ import print_function

import tensorflow as tf
from tensorflow.contrib import rnn
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True)

Comme mentionné ci-dessus, les bibliothèques aident à définir les données d'entrée, qui constituent la partie principale de la mise en œuvre récurrente du réseau neuronal.

Step 2- Notre principal motif est de classer les images à l'aide d'un réseau neuronal récurrent, où nous considérons chaque ligne d'image comme une séquence de pixels. La forme de l'image MNIST est spécifiquement définie comme 28 * 28 px. Nous allons maintenant gérer 28 séquences de 28 étapes pour chaque échantillon mentionné. Nous allons définir les paramètres d'entrée pour obtenir le motif séquentiel.

n_input = 28 # MNIST data input with img shape 28*28
n_steps = 28
n_hidden = 128
n_classes = 10

# tf Graph input
x = tf.placeholder("float", [None, n_steps, n_input])
y = tf.placeholder("float", [None, n_classes]
weights = {
   'out': tf.Variable(tf.random_normal([n_hidden, n_classes]))
}
biases = {
   'out': tf.Variable(tf.random_normal([n_classes]))
}

Step 3- Calculez les résultats en utilisant une fonction définie dans RNN pour obtenir les meilleurs résultats. Ici, chaque forme de données est comparée à la forme d'entrée actuelle et les résultats sont calculés pour maintenir le taux de précision.

def RNN(x, weights, biases):
   x = tf.unstack(x, n_steps, 1)

   # Define a lstm cell with tensorflow
   lstm_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)

   # Get lstm cell output
   outputs, states = rnn.static_rnn(lstm_cell, x, dtype = tf.float32)

   # Linear activation, using rnn inner loop last output
   return tf.matmul(outputs[-1], weights['out']) + biases['out']

pred = RNN(x, weights, biases)

# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = pred, labels = y))
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)

# Evaluate model
correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initializing the variables
init = tf.global_variables_initializer()

Step 4- Dans cette étape, nous allons lancer le graphe pour obtenir les résultats du calcul. Cela aide également à calculer la précision des résultats des tests.

with tf.Session() as sess:
   sess.run(init)
   step = 1
   # Keep training until reach max iterations
   
   while step * batch_size < training_iters:
      batch_x, batch_y = mnist.train.next_batch(batch_size)
      batch_x = batch_x.reshape((batch_size, n_steps, n_input))
      sess.run(optimizer, feed_dict={x: batch_x, y: batch_y})
      
      if step % display_step == 0:
         # Calculate batch accuracy
         acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y})
         
         # Calculate batch loss
         loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y})
         
         print("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \
            "{:.6f}".format(loss) + ", Training Accuracy= " + \
            "{:.5f}".format(acc))
      step += 1
   print("Optimization Finished!")
      test_len = 128
   test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))
   
   test_label = mnist.test.labels[:test_len]
   print("Testing Accuracy:", \
      sess.run(accuracy, feed_dict={x: test_data, y: test_label}))

Les captures d'écran ci-dessous montrent la sortie générée -

TensorFlow comprend un outil de visualisation, appelé TensorBoard. Il est utilisé pour analyser le graphique de flux de données et également pour comprendre les modèles d'apprentissage automatique. La caractéristique importante de TensorBoard comprend une vue de différents types de statistiques sur les paramètres et les détails de tout graphique en alignement vertical.

Le réseau de neurones profonds comprend jusqu'à 36 000 nœuds. TensorBoard aide à réduire ces nœuds dans des blocs de haut niveau et à mettre en évidence les structures identiques. Cela permet une meilleure analyse du graphe en se concentrant sur les sections primaires du graphe de calcul. La visualisation TensorBoard est dite très interactive où un utilisateur peut effectuer un panoramique, zoomer et étendre les nœuds pour afficher les détails.

La représentation schématique suivante montre le fonctionnement complet de la visualisation TensorBoard -

Les algorithmes regroupent les nœuds en blocs de haut niveau et mettent en évidence les groupes spécifiques avec des structures identiques, qui séparent les nœuds de haut degré. Le TensorBoard ainsi créé est utile et est traité tout aussi important pour le réglage d'un modèle d'apprentissage automatique. Cet outil de visualisation est conçu pour le fichier journal de configuration avec des informations récapitulatives et des détails qui doivent être affichés.

Concentrons-nous sur l'exemple de démonstration de la visualisation TensorBoard à l'aide du code suivant -

import tensorflow as tf 

# Constants creation for TensorBoard visualization 
a = tf.constant(10,name = "a") 
b = tf.constant(90,name = "b") 
y = tf.Variable(a+b*2,name = 'y') 
model = tf.initialize_all_variables() #Creation of model 

with tf.Session() as session: 
   merged = tf.merge_all_summaries() 
   writer = tf.train.SummaryWriter("/tmp/tensorflowlogs",session.graph) 
   session.run(model) 
   print(session.run(y))

Le tableau suivant montre les différents symboles de la visualisation TensorBoard utilisés pour la représentation des nœuds -

L'incorporation de mots est le concept de mappage d'objets discrets tels que des mots vers des vecteurs et des nombres réels. Il est important pour les entrées pour l'apprentissage automatique. Le concept comprend des fonctions standard, qui transforment efficacement les objets d'entrée discrets en vecteurs utiles.

L'exemple d'illustration de l'entrée de l'incorporation de mots est comme indiqué ci-dessous -

blue: (0.01359, 0.00075997, 0.24608, ..., -0.2524, 1.0048, 0.06259)
blues: (0.01396, 0.11887, -0.48963, ..., 0.033483, -0.10007, 0.1158)
orange: (-0.24776, -0.12359, 0.20986, ..., 0.079717, 0.23865, -0.014213)
oranges: (-0.35609, 0.21854, 0.080944, ..., -0.35413, 0.38511, -0.070976)

Word2vec

Word2vec est l'approche la plus courante utilisée pour la technique d'incorporation de mots non supervisée. Il entraîne le modèle de telle manière qu'un mot d'entrée donné prédit le contexte du mot en utilisant des skip-grammes.

TensorFlow permet de nombreuses façons d'implémenter ce type de modèle avec des niveaux croissants de sophistication et d'optimisation et en utilisant des concepts multithreading et des abstractions de plus haut niveau.

import os 
import math 
import numpy as np 
import tensorflow as tf 

from tensorflow.contrib.tensorboard.plugins import projector 
batch_size = 64 
embedding_dimension = 5 
negative_samples = 8 
LOG_DIR = "logs/word2vec_intro" 

digit_to_word_map = {
   1: "One", 
   2: "Two", 
   3: "Three", 
   4: "Four", 
   5: "Five", 
   6: "Six", 
   7: "Seven", 
   8: "Eight", 
   9: "Nine"} 
sentences = [] 

# Create two kinds of sentences - sequences of odd and even digits. 
   for i in range(10000): 
   rand_odd_ints = np.random.choice(range(1, 10, 2), 3) 
      sentences.append(" ".join([digit_to_word_map[r] for r in rand_odd_ints])) 
   rand_even_ints = np.random.choice(range(2, 10, 2), 3) 
      sentences.append(" ".join([digit_to_word_map[r] for r in rand_even_ints])) 
   
# Map words to indices
word2index_map = {} 
index = 0 

for sent in sentences: 
   for word in sent.lower().split(): 
   
   if word not in word2index_map: 
      word2index_map[word] = index 
      index += 1 
index2word_map = {index: word for word, index in word2index_map.items()} 

vocabulary_size = len(index2word_map) 

# Generate skip-gram pairs 
skip_gram_pairs = [] 

for sent in sentences: 
   tokenized_sent = sent.lower().split() 
   
   for i in range(1, len(tokenized_sent)-1):        
      word_context_pair = [[word2index_map[tokenized_sent[i-1]], 
         word2index_map[tokenized_sent[i+1]]], word2index_map[tokenized_sent[i]]] 
      
      skip_gram_pairs.append([word_context_pair[1], word_context_pair[0][0]]) 
      skip_gram_pairs.append([word_context_pair[1], word_context_pair[0][1]]) 

def get_skipgram_batch(batch_size): 
   instance_indices = list(range(len(skip_gram_pairs))) 
      np.random.shuffle(instance_indices)
   batch = instance_indices[:batch_size] 
   x = [skip_gram_pairs[i][0] for i in batch] 
   y = [[skip_gram_pairs[i][1]] for i in batch] 
   return x, y 
   
# batch example 
x_batch, y_batch = get_skipgram_batch(8) 
x_batch 
y_batch 
[index2word_map[word] for word in x_batch] [index2word_map[word[0]] for word in y_batch] 

# Input data, labels train_inputs = tf.placeholder(tf.int32, shape = [batch_size]) 
   train_labels = tf.placeholder(tf.int32, shape = [batch_size, 1]) 

# Embedding lookup table currently only implemented in CPU with 
   tf.name_scope("embeddings"): 
   embeddings = tf.Variable(    
      tf.random_uniform([vocabulary_size, embedding_dimension], -1.0, 1.0), 
         name = 'embedding') 
   # This is essentialy a lookup table 
   embed = tf.nn.embedding_lookup(embeddings, train_inputs) 
   
# Create variables for the NCE loss
nce_weights = tf.Variable(     
   tf.truncated_normal([vocabulary_size, embedding_dimension], stddev = 1.0 / 
      math.sqrt(embedding_dimension))) 
   
nce_biases = tf.Variable(tf.zeros([vocabulary_size])) 

loss = tf.reduce_mean(     
   tf.nn.nce_loss(weights = nce_weights, biases = nce_biases, inputs = embed, 
   labels = train_labels,num_sampled = negative_samples, 
   num_classes = vocabulary_size)) tf.summary.scalar("NCE_loss", loss) 
   
# Learning rate decay 
global_step = tf.Variable(0, trainable = False) 
   learningRate = tf.train.exponential_decay(learning_rate = 0.1, 
   global_step = global_step, decay_steps = 1000, decay_rate = 0.95, staircase = True) 

train_step = tf.train.GradientDescentOptimizer(learningRate).minimize(loss) 
   merged = tf.summary.merge_all() 
with tf.Session() as sess: 
   train_writer = tf.summary.FileWriter(LOG_DIR,    
      graph = tf.get_default_graph()) 
   saver = tf.train.Saver() 
   
   with open(os.path.join(LOG_DIR, 'metadata.tsv'), "w") as metadata: 
      metadata.write('Name\tClass\n') for k, v in index2word_map.items(): 
      metadata.write('%s\t%d\n' % (v, k)) 
   
   config = projector.ProjectorConfig() 
   embedding = config.embeddings.add() embedding.tensor_name = embeddings.name 
   
   # Link this tensor to its metadata file (e.g. labels). 
   embedding.metadata_path = os.path.join(LOG_DIR, 'metadata.tsv') 
      projector.visualize_embeddings(train_writer, config) 
   
   tf.global_variables_initializer().run() 
   
   for step in range(1000): 
      x_batch, y_batch = get_skipgram_batch(batch_size) summary, _ = sess.run(
         [merged, train_step], feed_dict = {train_inputs: x_batch, train_labels: y_batch})
      train_writer.add_summary(summary, step)
      
      if step % 100 == 0:
         saver.save(sess, os.path.join(LOG_DIR, "w2v_model.ckpt"), step)
         loss_value = sess.run(loss, feed_dict = {
            train_inputs: x_batch, train_labels: y_batch})
         print("Loss at %d: %.5f" % (step, loss_value))

   # Normalize embeddings before using
   norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keep_dims = True))
   normalized_embeddings = embeddings /
      norm normalized_embeddings_matrix = sess.run(normalized_embeddings)
   
ref_word = normalized_embeddings_matrix[word2index_map["one"]]

cosine_dists = np.dot(normalized_embeddings_matrix, ref_word)
ff = np.argsort(cosine_dists)[::-1][1:10] for f in ff: print(index2word_map[f])
print(cosine_dists[f])

Production

Le code ci-dessus génère la sortie suivante -

Pour comprendre le perceptron monocouche, il est important de comprendre les réseaux de neurones artificiels (ANN). Les réseaux neuronaux artificiels sont le système de traitement de l'information dont le mécanisme s'inspire de la fonctionnalité des circuits neuronaux biologiques. Un réseau neuronal artificiel possède de nombreuses unités de traitement connectées les unes aux autres. Voici la représentation schématique du réseau neuronal artificiel -

Le diagramme montre que les unités masquées communiquent avec la couche externe. Alors que les unités d'entrée et de sortie communiquent uniquement à travers la couche cachée du réseau.

Le schéma de connexion avec les nœuds, le nombre total de couches et le niveau de nœuds entre les entrées et les sorties avec le nombre de neurones par couche définissent l'architecture d'un réseau de neurones.

Il existe deux types d'architecture. Ces types se concentrent sur la fonctionnalité des réseaux de neurones artificiels comme suit -

  • Perceptron monocouche
  • Perceptron multicouche

Perceptron monocouche

Le perceptron monocouche est le premier modèle neuronal proposé créé. Le contenu de la mémoire locale du neurone est constitué d'un vecteur de poids. Le calcul d'un perceptron monocouche est effectué sur le calcul de la somme du vecteur d'entrée chacun avec la valeur multipliée par l'élément correspondant du vecteur des poids. La valeur affichée dans la sortie sera l'entrée d'une fonction d'activation.

Concentrons-nous sur l'implémentation du perceptron monocouche pour un problème de classification d'images utilisant TensorFlow. Le meilleur exemple pour illustrer le perceptron à couche unique est la représentation de la «régression logistique».

Maintenant, considérons les étapes de base suivantes de la régression logistique d'entraînement -

  • Les poids sont initialisés avec des valeurs aléatoires au début de la formation.

  • Pour chaque élément de l'ensemble d'apprentissage, l'erreur est calculée avec la différence entre la sortie souhaitée et la sortie réelle. L'erreur calculée est utilisée pour ajuster les poids.

  • Le processus est répété jusqu'à ce que l'erreur commise sur l'ensemble de l'entraînement ne soit pas inférieure au seuil spécifié, jusqu'à ce que le nombre maximal d'itérations soit atteint.

Le code complet d'évaluation de la régression logistique est mentionné ci-dessous -

# Import MINST data 
from tensorflow.examples.tutorials.mnist import input_data 
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True) 

import tensorflow as tf 
import matplotlib.pyplot as plt 

# Parameters 
learning_rate = 0.01 
training_epochs = 25 
batch_size = 100 
display_step = 1 

# tf Graph Input 
x = tf.placeholder("float", [None, 784]) # mnist data image of shape 28*28 = 784 
y = tf.placeholder("float", [None, 10]) # 0-9 digits recognition => 10 classes 

# Create model 
# Set model weights 
W = tf.Variable(tf.zeros([784, 10])) 
b = tf.Variable(tf.zeros([10])) 

# Construct model 
activation = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax 

# Minimize error using cross entropy 
cross_entropy = y*tf.log(activation) 
cost = tf.reduce_mean\ (-tf.reduce_sum\ (cross_entropy,reduction_indices = 1)) 

optimizer = tf.train.\ GradientDescentOptimizer(learning_rate).minimize(cost) 

#Plot settings 
avg_set = [] 
epoch_set = [] 

# Initializing the variables init = tf.initialize_all_variables()
# Launch the graph 
with tf.Session() as sess:
   sess.run(init)
   
   # Training cycle
   for epoch in range(training_epochs):
      avg_cost = 0.
      total_batch = int(mnist.train.num_examples/batch_size)
      
      # Loop over all batches
      for i in range(total_batch):
         batch_xs, batch_ys = \ mnist.train.next_batch(batch_size)
         # Fit training using batch data sess.run(optimizer, \ feed_dict = {
            x: batch_xs, y: batch_ys}) 
         # Compute average loss avg_cost += sess.run(cost, \ feed_dict = {
            x: batch_xs, \ y: batch_ys})/total_batch
      # Display logs per epoch step
      if epoch % display_step == 0:
         print ("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))
            avg_set.append(avg_cost) epoch_set.append(epoch+1)
   print ("Training phase finished")
    
   plt.plot(epoch_set,avg_set, 'o', label = 'Logistic Regression Training phase') 
   plt.ylabel('cost') 
   plt.xlabel('epoch') 
   plt.legend() 
   plt.show() 
    
   # Test model 
   correct_prediction = tf.equal(tf.argmax(activation, 1), tf.argmax(y, 1)) 
   
   # Calculate accuracy 
   accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) print 
      ("Model accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))

Production

Le code ci-dessus génère la sortie suivante -

La régression logistique est considérée comme une analyse prédictive. La régression logistique est utilisée pour décrire les données et pour expliquer la relation entre une variable binaire dépendante et une ou plusieurs variables nominales ou indépendantes.

Dans ce chapitre, nous nous concentrerons sur l'exemple de base d'implémentation de régression linéaire à l'aide de TensorFlow. La régression logistique ou régression linéaire est une approche d'apprentissage automatique supervisé pour la classification des catégories discrètes d'ordre. Notre objectif dans ce chapitre est de construire un modèle par lequel un utilisateur peut prédire la relation entre les variables prédictives et une ou plusieurs variables indépendantes.

La relation entre ces deux variables est considérée comme linéaire. Si y est la variable dépendante et x est considéré comme la variable indépendante, alors la relation de régression linéaire de deux variables ressemblera à l'équation suivante -

Y = Ax+b

Nous allons concevoir un algorithme de régression linéaire. Cela nous permettra de comprendre les deux concepts importants suivants -

  • Fonction de coût
  • Algorithmes de descente de gradient

La représentation schématique de la régression linéaire est mentionnée ci-dessous -

La vue graphique de l'équation de régression linéaire est mentionnée ci-dessous -

Étapes pour concevoir un algorithme de régression linéaire

Nous allons maintenant découvrir les étapes qui aident à concevoir un algorithme de régression linéaire.

Étape 1

Il est important d'importer les modules nécessaires pour tracer le module de régression linéaire. Nous commençons à importer la bibliothèque Python NumPy et Matplotlib.

import numpy as np 
import matplotlib.pyplot as plt

Étape 2

Définissez le nombre de coefficients nécessaires à la régression logistique.

number_of_points = 500 
x_point = [] 
y_point = [] 
a = 0.22 
b = 0.78

Étape 3

Itérer les variables pour générer 300 points aléatoires autour de l'équation de régression -

Y = 0,22x + 0,78

for i in range(number_of_points): 
   x = np.random.normal(0.0,0.5) 
   y = a*x + b +np.random.normal(0.0,0.1) x_point.append([x]) 
   y_point.append([y])

Étape 4

Visualisez les points générés à l'aide de Matplotlib.

fplt.plot(x_point,y_point, 'o', label = 'Input Data') plt.legend() plt.show()

Le code complet de la régression logistique est le suivant -

import numpy as np 
import matplotlib.pyplot as plt 

number_of_points = 500 
x_point = [] 
y_point = [] 
a = 0.22 
b = 0.78 

for i in range(number_of_points): 
   x = np.random.normal(0.0,0.5) 
   y = a*x + b +np.random.normal(0.0,0.1) x_point.append([x]) 
   y_point.append([y]) 
   
plt.plot(x_point,y_point, 'o', label = 'Input Data') plt.legend() 
plt.show()

Le nombre de points pris en entrée est considéré comme des données d'entrée.

TFLearn peut être défini comme un aspect d'apprentissage profond modulaire et transparent utilisé dans le framework TensorFlow. Le principal objectif de TFLearn est de fournir une API de niveau supérieur à TensorFlow pour faciliter et présenter de nouvelles expériences.

Tenez compte des caractéristiques importantes suivantes de TFLearn -

  • TFLearn est facile à utiliser et à comprendre.

  • Il comprend des concepts simples pour créer des couches de réseau hautement modulaires, des optimiseurs et diverses mesures intégrées.

  • Il inclut une transparence totale avec le système de travail TensorFlow.

  • Il comprend de puissantes fonctions d'assistance pour entraîner les tenseurs intégrés qui acceptent plusieurs entrées, sorties et optimiseurs.

  • Il comprend une visualisation graphique simple et belle.

  • La visualisation graphique comprend divers détails sur les poids, les dégradés et les activations.

Installez TFLearn en exécutant la commande suivante -

pip install tflearn

Lors de l'exécution du code ci-dessus, la sortie suivante sera générée -

L'illustration suivante montre l'implémentation de TFLearn avec le classificateur Random Forest -

from __future__ import division, print_function, absolute_import

#TFLearn module implementation
import tflearn
from tflearn.estimators import RandomForestClassifier

# Data loading and pre-processing with respect to dataset
import tflearn.datasets.mnist as mnist
X, Y, testX, testY = mnist.load_data(one_hot = False)

m = RandomForestClassifier(n_estimators = 100, max_nodes = 1000)
m.fit(X, Y, batch_size = 10000, display_step = 10)

print("Compute the accuracy on train data:")
print(m.evaluate(X, Y, tflearn.accuracy_op))

print("Compute the accuracy on test set:")
print(m.evaluate(testX, testY, tflearn.accuracy_op))

print("Digits for test images id 0 to 5:")
print(m.predict(testX[:5]))

print("True digits:")
print(testY[:5])

Dans ce chapitre, nous nous concentrerons sur la différence entre CNN et RNN -

CNN RNN
Il convient aux données spatiales telles que les images. RNN convient aux données temporelles, également appelées données séquentielles.
CNN est considéré comme plus puissant que RNN. RNN inclut moins de compatibilité des fonctionnalités par rapport à CNN.
Ce réseau prend des entrées de taille fixe et génère des sorties de taille fixe. RNN peut gérer des longueurs d'entrée / sortie arbitraires.
CNN est un type de réseau neuronal artificiel à réaction avec des variations de perceptrons multicouches conçus pour utiliser des quantités minimales de prétraitement. RNN contrairement aux réseaux de neurones à réaction directe - peut utiliser sa mémoire interne pour traiter des séquences arbitraires d'entrées.
Les CNN utilisent un modèle de connectivité entre les neurones. Ceci est inspiré par l'organisation du cortex visuel animal, dont les neurones individuels sont disposés de telle manière qu'ils répondent aux régions qui se chevauchent carrelant le champ visuel. Les réseaux de neurones récurrents utilisent des informations de séries chronologiques - ce qu'un utilisateur a parlé en dernier aura un impact sur ce qu'il parlera ensuite.
Les CNN sont idéaux pour les images et le traitement vidéo. Les RNN sont idéaux pour l'analyse du texte et de la parole.

L'illustration suivante montre la représentation schématique de CNN et RNN -

Keras est une bibliothèque Python compacte, facile à apprendre et de haut niveau exécutée sur le framework TensorFlow. Il est conçu en mettant l'accent sur la compréhension des techniques d'apprentissage en profondeur, telles que la création de couches pour les réseaux de neurones en maintenant les concepts de formes et de détails mathématiques. La création de freamework peut être des deux types suivants -

  • API séquentielle
  • API fonctionnelle

Considérez les huit étapes suivantes pour créer un modèle d'apprentissage en profondeur dans Keras -

  • Chargement des données
  • Prétraitez les données chargées
  • Définition du modèle
  • Compiler le modèle
  • Ajuster le modèle spécifié
  • Évaluer
  • Faites les prédictions requises
  • Enregistrer le modèle

Nous allons utiliser Jupyter Notebook pour l'exécution et l'affichage de la sortie comme indiqué ci-dessous -

Step 1 - Le chargement des données et le prétraitement des données chargées sont d'abord mis en œuvre pour exécuter le modèle d'apprentissage en profondeur.

import warnings
warnings.filterwarnings('ignore')

import numpy as np
np.random.seed(123) # for reproducibility

from keras.models import Sequential
from keras.layers import Flatten, MaxPool2D, Conv2D, Dense, Reshape, Dropout
from keras.utils import np_utils
Using TensorFlow backend.
from keras.datasets import mnist

# Load pre-shuffled MNIST data into train and test sets
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)
X_test = X_test.reshape(X_test.shape[0], 28, 28, 1)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
Y_train = np_utils.to_categorical(y_train, 10)
Y_test = np_utils.to_categorical(y_test, 10)

Cette étape peut être définie comme «Importer des bibliothèques et des modules», ce qui signifie que toutes les bibliothèques et modules sont importés en tant qu'étape initiale.

Step 2 - Dans cette étape, nous définirons l'architecture du modèle -

model = Sequential()
model.add(Conv2D(32, 3, 3, activation = 'relu', input_shape = (28,28,1)))
model.add(Conv2D(32, 3, 3, activation = 'relu'))
model.add(MaxPool2D(pool_size = (2,2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation = 'relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation = 'softmax'))

Step 3 - Compilons maintenant le modèle spécifié -

model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])

Step 4 - Nous allons maintenant ajuster le modèle en utilisant les données d'entraînement -

model.fit(X_train, Y_train, batch_size = 32, epochs = 10, verbose = 1)

La sortie des itérations créées est la suivante -

Epoch 1/10 60000/60000 [==============================] - 65s - 
loss: 0.2124 - 
acc: 0.9345 
Epoch 2/10 60000/60000 [==============================] - 62s - 
loss: 0.0893 - 
acc: 0.9740 
Epoch 3/10 60000/60000 [==============================] - 58s - 
loss: 0.0665 - 
acc: 0.9802 
Epoch 4/10 60000/60000 [==============================] - 62s - 
loss: 0.0571 - 
acc: 0.9830 
Epoch 5/10 60000/60000 [==============================] - 62s - 
loss: 0.0474 - 
acc: 0.9855 
Epoch 6/10 60000/60000 [==============================] - 59s -
loss: 0.0416 - 
acc: 0.9871 
Epoch 7/10 60000/60000 [==============================] - 61s - 
loss: 0.0380 - 
acc: 0.9877 
Epoch 8/10 60000/60000 [==============================] - 63s - 
loss: 0.0333 - 
acc: 0.9895 
Epoch 9/10 60000/60000 [==============================] - 64s - 
loss: 0.0325 - 
acc: 0.9898 
Epoch 10/10 60000/60000 [==============================] - 60s - 
loss: 0.0284 - 
acc: 0.9910

Ce chapitre se concentrera sur la façon de démarrer avec TensorFlow distribué. L'objectif est d'aider les développeurs à comprendre les concepts de base de TF distribués qui se reproduisent, tels que les serveurs TF. Nous utiliserons Jupyter Notebook pour évaluer le TensorFlow distribué. La mise en œuvre de l'informatique distribuée avec TensorFlow est mentionnée ci-dessous -

Step 1 - Importer les modules nécessaires obligatoires pour le calcul distribué -

import tensorflow as tf

Step 2- Créez un cluster TensorFlow avec un nœud. Laissez ce nœud être responsable d'un travail qui porte le nom «worker» et qui exécutera une prise sur localhost: 2222.

cluster_spec = tf.train.ClusterSpec({'worker' : ['localhost:2222']})
server = tf.train.Server(cluster_spec)
server.target

Les scripts ci-dessus génèrent la sortie suivante -

'grpc://localhost:2222'
The server is currently running.

Step 3 - La configuration du serveur avec la session respective peut être calculée en exécutant la commande suivante -

server.server_def

La commande ci-dessus génère la sortie suivante -

cluster {
   job {
      name: "worker"
      tasks {
         value: "localhost:2222"
      }
   }
}
job_name: "worker"
protocol: "grpc"

Step 4- Lancez une session TensorFlow avec le moteur d'exécution étant le serveur. Utilisez TensorFlow pour créer un serveur local et utiliserlsof pour connaître l'emplacement du serveur.

sess = tf.Session(target = server.target)
server = tf.train.Server.create_local_server()

Step 5 - Afficher les appareils disponibles dans cette session et fermer la session respective.

devices = sess.list_devices()
for d in devices:
   print(d.name)
sess.close()

La commande ci-dessus génère la sortie suivante -

/job:worker/replica:0/task:0/device:CPU:0

Ici, nous nous concentrerons sur la formation MetaGraph dans TensorFlow. Cela nous aidera à comprendre le module d'exportation dans TensorFlow. Le MetaGraph contient les informations de base nécessaires pour entraîner, effectuer une évaluation ou exécuter une inférence sur un graphe préalablement entraîné.

Voici l'extrait de code pour le même -

def export_meta_graph(filename = None, collection_list = None, as_text = False): 
   """this code writes `MetaGraphDef` to save_path/filename. 
   
   Arguments: 
   filename: Optional meta_graph filename including the path. collection_list: 
      List of string keys to collect. as_text: If `True`, 
      writes the meta_graph as an ASCII proto. 
   
   Returns: 
   A `MetaGraphDef` proto. """

L'un des modèles d'utilisation typiques pour le même est mentionné ci-dessous -

# Build the model ... 
with tf.Session() as sess: 
   # Use the model ... 
# Export the model to /tmp/my-model.meta. 
meta_graph_def = tf.train.export_meta_graph(filename = '/tmp/my-model.meta')

Le perceptron multi-couches définit l'architecture la plus compliquée des réseaux de neurones artificiels. Il est essentiellement formé de plusieurs couches de perceptron.

La représentation schématique de l'apprentissage du perceptron multicouche est illustrée ci-dessous -

Les réseaux MLP sont généralement utilisés pour le format d'apprentissage supervisé. Un algorithme d'apprentissage typique pour les réseaux MLP est également appelé algorithme de propagation arrière.

Maintenant, nous allons nous concentrer sur l'implémentation avec MLP pour un problème de classification d'image.

# Import MINST data 
from tensorflow.examples.tutorials.mnist import input_data 
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True) 

import tensorflow as tf 
import matplotlib.pyplot as plt 

# Parameters 
learning_rate = 0.001 
training_epochs = 20 
batch_size = 100 
display_step = 1 

# Network Parameters 
n_hidden_1 = 256 

# 1st layer num features
n_hidden_2 = 256 # 2nd layer num features 
n_input = 784 # MNIST data input (img shape: 28*28) n_classes = 10 
# MNIST total classes (0-9 digits) 

# tf Graph input 
x = tf.placeholder("float", [None, n_input]) 
y = tf.placeholder("float", [None, n_classes]) 

# weights layer 1 
h = tf.Variable(tf.random_normal([n_input, n_hidden_1])) # bias layer 1 
bias_layer_1 = tf.Variable(tf.random_normal([n_hidden_1])) 
# layer 1 layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, h), bias_layer_1)) 

# weights layer 2 
w = tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])) 

# bias layer 2 
bias_layer_2 = tf.Variable(tf.random_normal([n_hidden_2])) 

# layer 2 
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, w), bias_layer_2)) 

# weights output layer 
output = tf.Variable(tf.random_normal([n_hidden_2, n_classes])) 

# biar output layer 
bias_output = tf.Variable(tf.random_normal([n_classes])) # output layer 
output_layer = tf.matmul(layer_2, output) + bias_output

# cost function 
cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(
   logits = output_layer, labels = y)) 

#cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(output_layer, y)) 
# optimizer 
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost) 

# optimizer = tf.train.GradientDescentOptimizer(
   learning_rate = learning_rate).minimize(cost) 

# Plot settings 
avg_set = [] 
epoch_set = [] 

# Initializing the variables 
init = tf.global_variables_initializer() 

# Launch the graph 
with tf.Session() as sess: 
   sess.run(init) 
   
   # Training cycle
   for epoch in range(training_epochs): 
      avg_cost = 0. 
      total_batch = int(mnist.train.num_examples / batch_size) 
      
      # Loop over all batches 
      for i in range(total_batch): 
         batch_xs, batch_ys = mnist.train.next_batch(batch_size) 
         # Fit training using batch data sess.run(optimizer, feed_dict = {
            x: batch_xs, y: batch_ys}) 
         # Compute average loss 
         avg_cost += sess.run(cost, feed_dict = {x: batch_xs, y: batch_ys}) / total_batch
      # Display logs per epoch step 
      if epoch % display_step == 0: 
         print 
         Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(avg_cost)
      avg_set.append(avg_cost) 
      epoch_set.append(epoch + 1)
   print 
   "Training phase finished" 
   
   plt.plot(epoch_set, avg_set, 'o', label = 'MLP Training phase') 
   plt.ylabel('cost') 
   plt.xlabel('epoch') 
   plt.legend() 
   plt.show() 
   
   # Test model 
   correct_prediction = tf.equal(tf.argmax(output_layer, 1), tf.argmax(y, 1)) 
   
   # Calculate accuracy 
   accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) 
   print 
   "Model Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels})

La ligne de code ci-dessus génère la sortie suivante -

Dans ce chapitre, nous nous concentrerons sur le réseau que nous devrons apprendre à partir d'un ensemble connu de points appelés x et f (x). Une seule couche cachée construira ce réseau simple.

Le code pour l'explication des couches cachées de perceptron est comme indiqué ci-dessous -

#Importing the necessary modules 
import tensorflow as tf 
import numpy as np 
import math, random 
import matplotlib.pyplot as plt 

np.random.seed(1000) 
function_to_learn = lambda x: np.cos(x) + 0.1*np.random.randn(*x.shape) 
layer_1_neurons = 10 
NUM_points = 1000 

#Training the parameters 
batch_size = 100 
NUM_EPOCHS = 1500 

all_x = np.float32(np.random.uniform(-2*math.pi, 2*math.pi, (1, NUM_points))).T 
   np.random.shuffle(all_x) 

train_size = int(900) 
#Training the first 700 points in the given set x_training = all_x[:train_size] 
y_training = function_to_learn(x_training)

#Training the last 300 points in the given set x_validation = all_x[train_size:] 
y_validation = function_to_learn(x_validation) 

plt.figure(1) 
plt.scatter(x_training, y_training, c = 'blue', label = 'train') 
plt.scatter(x_validation, y_validation, c = 'pink', label = 'validation') 
plt.legend() 
plt.show()

X = tf.placeholder(tf.float32, [None, 1], name = "X")
Y = tf.placeholder(tf.float32, [None, 1], name = "Y")

#first layer 
#Number of neurons = 10 
w_h = tf.Variable(
   tf.random_uniform([1, layer_1_neurons],\ minval = -1, maxval = 1, dtype = tf.float32)) 
b_h = tf.Variable(tf.zeros([1, layer_1_neurons], dtype = tf.float32)) 
h = tf.nn.sigmoid(tf.matmul(X, w_h) + b_h)

#output layer 
#Number of neurons = 10 
w_o = tf.Variable(
   tf.random_uniform([layer_1_neurons, 1],\ minval = -1, maxval = 1, dtype = tf.float32)) 
b_o = tf.Variable(tf.zeros([1, 1], dtype = tf.float32)) 

#build the model 
model = tf.matmul(h, w_o) + b_o 

#minimize the cost function (model - Y) 
train_op = tf.train.AdamOptimizer().minimize(tf.nn.l2_loss(model - Y)) 

#Start the Learning phase 
sess = tf.Session() sess.run(tf.initialize_all_variables()) 

errors = [] 
for i in range(NUM_EPOCHS): 
   for start, end in zip(range(0, len(x_training), batch_size),\ 
      range(batch_size, len(x_training), batch_size)): 
      sess.run(train_op, feed_dict = {X: x_training[start:end],\ Y: y_training[start:end]})
   cost = sess.run(tf.nn.l2_loss(model - y_validation),\ feed_dict = {X:x_validation}) 
   errors.append(cost) 
   
   if i%100 == 0: 
      print("epoch %d, cost = %g" % (i, cost)) 
      
plt.plot(errors,label='MLP Function Approximation') plt.xlabel('epochs') 
plt.ylabel('cost') 
plt.legend() 
plt.show()

Production

Voici la représentation de l'approximation de la couche de fonction -

Ici, deux données sont représentées en forme de W. Les deux données sont: le train et la validation qui sont représentés dans des couleurs distinctes comme visible dans la section légende.

Les optimiseurs sont la classe étendue, qui incluent des informations supplémentaires pour entraîner un modèle spécifique. La classe d'optimisation est initialisée avec des paramètres donnés, mais il est important de se rappeler qu'aucun Tensor n'est nécessaire. Les optimiseurs sont utilisés pour améliorer la vitesse et les performances pour entraîner un modèle spécifique.

L'optimiseur de base de TensorFlow est -

tf.train.Optimizer

Cette classe est définie dans le chemin spécifié de tensorflow / python / training / optimizer.py.

Voici quelques optimiseurs dans Tensorflow -

  • Descente de gradient stochastique
  • Descente de gradient stochastique avec découpage de gradient
  • Momentum
  • L'élan de Nesterov
  • Adagrad
  • Adadelta
  • RMSProp
  • Adam
  • Adamax
  • SMORMS3

Nous nous concentrerons sur la descente du gradient stochastique. L'illustration pour créer un optimiseur pour le même est mentionnée ci-dessous -

def sgd(cost, params, lr = np.float32(0.01)):
   g_params = tf.gradients(cost, params)
   updates = []
   
   for param, g_param in zip(params, g_params):
      updates.append(param.assign(param - lr*g_param))
   return updates

Les paramètres de base sont définis dans la fonction spécifique. Dans notre prochain chapitre, nous nous concentrerons sur l'optimisation de la descente de gradient avec la mise en œuvre d'optimiseurs.

Dans ce chapitre, nous découvrirons l'implémentation XOR à l'aide de TensorFlow. Avant de commencer avec l'implémentation XOR dans TensorFlow, voyons les valeurs de la table XOR. Cela nous aidera à comprendre le processus de cryptage et de décryptage.

UNE B UNE XOR B
0 0 0
0 1 1
1 0 1
1 1 0

La méthode de cryptage XOR Cipher est essentiellement utilisée pour crypter des données difficiles à craquer avec la méthode de la force brute, c'est-à-dire en générant des clés de cryptage aléatoires qui correspondent à la clé appropriée.

Le concept de mise en œuvre avec XOR Cipher consiste à définir une clé de chiffrement XOR, puis à effectuer une opération XOR sur les caractères de la chaîne spécifiée avec cette clé, qu'un utilisateur tente de chiffrer. Nous allons maintenant nous concentrer sur l'implémentation XOR à l'aide de TensorFlow, qui est mentionnée ci-dessous -

#Declaring necessary modules
import tensorflow as tf
import numpy as np
"""
A simple numpy implementation of a XOR gate to understand the backpropagation
algorithm
"""

x = tf.placeholder(tf.float64,shape = [4,2],name = "x")
#declaring a place holder for input x
y = tf.placeholder(tf.float64,shape = [4,1],name = "y")
#declaring a place holder for desired output y

m = np.shape(x)[0]#number of training examples
n = np.shape(x)[1]#number of features
hidden_s = 2 #number of nodes in the hidden layer
l_r = 1#learning rate initialization

theta1 = tf.cast(tf.Variable(tf.random_normal([3,hidden_s]),name = "theta1"),tf.float64)
theta2 = tf.cast(tf.Variable(tf.random_normal([hidden_s+1,1]),name = "theta2"),tf.float64)

#conducting forward propagation
a1 = tf.concat([np.c_[np.ones(x.shape[0])],x],1)
#the weights of the first layer are multiplied by the input of the first layer

z1 = tf.matmul(a1,theta1)
#the input of the second layer is the output of the first layer, passed through the 
   activation function and column of biases is added

a2 = tf.concat([np.c_[np.ones(x.shape[0])],tf.sigmoid(z1)],1)
#the input of the second layer is multiplied by the weights

z3 = tf.matmul(a2,theta2)
#the output is passed through the activation function to obtain the final probability

h3 = tf.sigmoid(z3)
cost_func = -tf.reduce_sum(y*tf.log(h3)+(1-y)*tf.log(1-h3),axis = 1)

#built in tensorflow optimizer that conducts gradient descent using specified 
   learning rate to obtain theta values

optimiser = tf.train.GradientDescentOptimizer(learning_rate = l_r).minimize(cost_func)

#setting required X and Y values to perform XOR operation
X = [[0,0],[0,1],[1,0],[1,1]]
Y = [[0],[1],[1],[0]]

#initializing all variables, creating a session and running a tensorflow session
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

#running gradient descent for each iteration and printing the hypothesis 
   obtained using the updated theta values
for i in range(100000):
   sess.run(optimiser, feed_dict = {x:X,y:Y})#setting place holder values using feed_dict
   if i%100==0:
      print("Epoch:",i)
      print("Hyp:",sess.run(h3,feed_dict = {x:X,y:Y}))

La ligne de code ci-dessus génère une sortie comme indiqué dans la capture d'écran ci-dessous -

L'optimisation de la descente de gradient est considérée comme un concept important en science des données.

Considérez les étapes ci-dessous pour comprendre la mise en œuvre de l'optimisation de la descente de gradient -

Étape 1

Incluez les modules nécessaires et la déclaration des variables x et y à travers lesquelles nous allons définir l'optimisation de la descente de gradient.

import tensorflow as tf

x = tf.Variable(2, name = 'x', dtype = tf.float32)
log_x = tf.log(x)
log_x_squared = tf.square(log_x)

optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(log_x_squared)

Étape 2

Initialisez les variables nécessaires et appelez les optimiseurs pour les définir et les appeler avec la fonction respective.

init = tf.initialize_all_variables()

def optimize():
   with tf.Session() as session:
      session.run(init)
      print("starting at", "x:", session.run(x), "log(x)^2:", session.run(log_x_squared))
      
      for step in range(10):
         session.run(train)
         print("step", step, "x:", session.run(x), "log(x)^2:", session.run(log_x_squared))
optimize()

La ligne de code ci-dessus génère une sortie comme indiqué dans la capture d'écran ci-dessous -

Nous pouvons voir que les époques et itérations nécessaires sont calculées comme indiqué dans la sortie.

Une équation différentielle partielle (PDE) est une équation différentielle, qui implique des dérivées partielles avec une fonction inconnue de plusieurs variables indépendantes. En référence aux équations aux dérivées partielles, nous nous concentrerons sur la création de nouveaux graphiques.

Supposons qu'il y ait un étang de dimension 500 * 500 carré -

N = 500

Maintenant, nous allons calculer l'équation différentielle partielle et former le graphe respectif en l'utilisant. Considérez les étapes ci-dessous pour le calcul du graphe.

Step 1 - Importez des bibliothèques pour la simulation.

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

Step 2 - Inclut des fonctions pour la transformation d'un tableau 2D en un noyau de convolution et une opération de convolution 2D simplifiée.

def make_kernel(a):
   a = np.asarray(a)
   a = a.reshape(list(a.shape) + [1,1])
   return tf.constant(a, dtype=1)

def simple_conv(x, k):
   """A simplified 2D convolution operation"""
   x = tf.expand_dims(tf.expand_dims(x, 0), -1)
   y = tf.nn.depthwise_conv2d(x, k, [1, 1, 1, 1], padding = 'SAME')
   return y[0, :, :, 0]

def laplace(x):
   """Compute the 2D laplacian of an array"""
   laplace_k = make_kernel([[0.5, 1.0, 0.5], [1.0, -6., 1.0], [0.5, 1.0, 0.5]])
   return simple_conv(x, laplace_k)
   
sess = tf.InteractiveSession()

Step 3 - Incluez le nombre d'itérations et calculez le graphique pour afficher les enregistrements en conséquence.

N = 500

# Initial Conditions -- some rain drops hit a pond

# Set everything to zero
u_init = np.zeros([N, N], dtype = np.float32)
ut_init = np.zeros([N, N], dtype = np.float32)

# Some rain drops hit a pond at random points
for n in range(100):
   a,b = np.random.randint(0, N, 2)
   u_init[a,b] = np.random.uniform()

plt.imshow(u_init)
plt.show()

# Parameters:
# eps -- time resolution
# damping -- wave damping
eps = tf.placeholder(tf.float32, shape = ())
damping = tf.placeholder(tf.float32, shape = ())

# Create variables for simulation state
U = tf.Variable(u_init)
Ut = tf.Variable(ut_init)

# Discretized PDE update rules
U_ = U + eps * Ut
Ut_ = Ut + eps * (laplace(U) - damping * Ut)

# Operation to update the state
step = tf.group(U.assign(U_), Ut.assign(Ut_))

# Initialize state to initial conditions
tf.initialize_all_variables().run()

# Run 1000 steps of PDE
for i in range(1000):
   # Step simulation
   step.run({eps: 0.03, damping: 0.04})
   
   # Visualize every 50 steps
   if i % 500 == 0:
      plt.imshow(U.eval())
      plt.show()

Les graphiques sont tracés comme indiqué ci-dessous -

TensorFlow inclut une fonction spéciale de reconnaissance d'image et ces images sont stockées dans un dossier spécifique. Avec des images relativement identiques, il sera facile d'implémenter cette logique à des fins de sécurité.

La structure de dossier de l'implémentation du code de reconnaissance d'image est comme indiqué ci-dessous -

Dataset_image inclut les images associées, qui doivent être chargées. Nous nous concentrerons sur la reconnaissance d'image avec notre logo défini. Les images sont chargées avec le script «load_data.py», ce qui permet de garder une note sur les différents modules de reconnaissance d'image en leur sein.

import pickle
from sklearn.model_selection import train_test_split
from scipy import misc

import numpy as np
import os

label = os.listdir("dataset_image")
label = label[1:]
dataset = []

for image_label in label:
   images = os.listdir("dataset_image/"+image_label)
   
   for image in images:
      img = misc.imread("dataset_image/"+image_label+"/"+image)
      img = misc.imresize(img, (64, 64))
      dataset.append((img,image_label))
X = []
Y = []

for input,image_label in dataset:
   X.append(input)
   Y.append(label.index(image_label))

X = np.array(X)
Y = np.array(Y)

X_train,y_train, = X,Y

data_set = (X_train,y_train)

save_label = open("int_to_word_out.pickle","wb")
pickle.dump(label, save_label)
save_label.close()

La formation des images aide à stocker les modèles reconnaissables dans le dossier spécifié.

import numpy
import matplotlib.pyplot as plt

from keras.layers import Dropout
from keras.layers import Flatten
from keras.constraints import maxnorm
from keras.optimizers import SGD
from keras.layers import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.utils import np_utils
from keras import backend as K

import load_data
from keras.models import Sequential
from keras.layers import Dense

import keras
K.set_image_dim_ordering('tf')

# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)

# load data
(X_train,y_train) = load_data.data_set

# normalize inputs from 0-255 to 0.0-1.0
X_train = X_train.astype('float32')

#X_test = X_test.astype('float32')
X_train = X_train / 255.0

#X_test = X_test / 255.0
# one hot encode outputs
y_train = np_utils.to_categorical(y_train)

#y_test = np_utils.to_categorical(y_test)
num_classes = y_train.shape[1]

# Create the model
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), padding = 'same', 
   activation = 'relu', kernel_constraint = maxnorm(3)))

model.add(Dropout(0.2))
model.add(Conv2D(32, (3, 3), activation = 'relu', padding = 'same', 
   kernel_constraint = maxnorm(3)))

model.add(MaxPooling2D(pool_size = (2, 2)))
model.add(Flatten())
model.add(Dense(512, activation = 'relu', kernel_constraint = maxnorm(3)))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation = 'softmax'))

# Compile model
epochs = 10
lrate = 0.01
decay = lrate/epochs
sgd = SGD(lr = lrate, momentum = 0.9, decay = decay, nesterov = False)
model.compile(loss = 'categorical_crossentropy', optimizer = sgd, metrics = ['accuracy'])
print(model.summary())

#callbacks = [keras.callbacks.EarlyStopping(
   monitor = 'val_loss', min_delta = 0, patience = 0, verbose = 0, mode = 'auto')]
callbacks = [keras.callbacks.TensorBoard(log_dir='./logs', 
   histogram_freq = 0, batch_size = 32, write_graph = True, write_grads = False, 
   write_images = True, embeddings_freq = 0, embeddings_layer_names = None, 
   embeddings_metadata = None)]

# Fit the model

model.fit(X_train, y_train, epochs = epochs, 
   batch_size = 32,shuffle = True,callbacks = callbacks)

# Final evaluation of the model
scores = model.evaluate(X_train, y_train, verbose = 0)
print("Accuracy: %.2f%%" % (scores[1]*100))

# serialize model to JSONx
model_json = model.to_json()
with open("model_face.json", "w") as json_file:
   json_file.write(model_json)

# serialize weights to HDF5
model.save_weights("model_face.h5")
print("Saved model to disk")

La ligne de code ci-dessus génère une sortie comme indiqué ci-dessous -

Dans ce chapitre, nous allons comprendre les différents aspects de la formation des réseaux neuronaux qui peuvent être implémentés à l'aide du framework TensorFlow.

Voici les dix recommandations qui peuvent être évaluées -

Propagation arrière

La rétro-propagation est une méthode simple pour calculer des dérivées partielles, qui comprend la forme de base de composition la mieux adaptée aux réseaux neuronaux.

Descente de gradient stochastique

En descente de gradient stochastique, un batchest le nombre total d'exemples qu'un utilisateur utilise pour calculer le gradient en une seule itération. Jusqu'à présent, on suppose que le lot a été l'ensemble de données complet. La meilleure illustration fonctionne à l'échelle de Google; les ensembles de données contiennent souvent des milliards, voire des centaines de milliards d'exemples.

Décroissance du taux d'apprentissage

L'adaptation du taux d'apprentissage est l'une des caractéristiques les plus importantes de l'optimisation de la descente de gradient. Ceci est crucial pour la mise en œuvre de TensorFlow.

Abandonner

Les réseaux neuronaux profonds avec un grand nombre de paramètres forment de puissants systèmes d'apprentissage automatique. Cependant, le sur-ajustement est un problème sérieux dans de tels réseaux.

Regroupement maximum

Le pooling maximal est un processus de discrétisation basé sur des échantillons. Le but est de sous-échantillonner une représentation d'entrée, ce qui réduit la dimensionnalité avec les hypothèses requises.

Mémoire à long terme (LSTM)

LSTM contrôle la décision sur les entrées à prendre dans le neurone spécifié. Il inclut le contrôle sur la décision de ce qui doit être calculé et quelle sortie doit être générée.