Tutoriel TensorFlow - Apprentissage en profondeur à l'aide de TensorFlow

J'ai conçu ce didacticiel TensorFlow pour les professionnels et les passionnés qui souhaitent appliquer l'algorithme d'apprentissage profond à l'aide de TensorFlow pour résoudre divers problèmes. TensorFlow est une bibliothèque d'apprentissage en profondeur open source basée sur le concept de graphiques de flux de données pour la création de modèles. Il vous permet de créer des réseaux de neurones à grande échelle avec de nombreuses couches.L'apprentissage de l'utilisation de cette bibliothèque est également une partie fondamentale de la .Voici les sujets qui seront abordés dans ce blog du didacticiel TensorFlow:

• Qu'est-ce que TensorFlow
• Principes de base du code TensorFlow
• Cas d'utilisation de TensorFlow

Que sont les tenseurs?

Dans ce tutoriel TensorFlow, avant de parler de TensorFlow, voyons d'abord quels sont les tenseurs . Les tenseurs ne sont rien d'autre qu'un de facto pour représenter les données dans le deep learning.

Comme le montre l'image ci-dessus, les tenseurs ne sont que des tableaux multidimensionnels, qui vous permettent de représenter des données ayant des dimensions plus élevées. En général, le Deep Learning vous traite des ensembles de données de grande dimension où les dimensions font référence à différentes fonctionnalités présentes dans l'ensemble de données. En fait, le nom «TensorFlow» est dérivé des opérations que les réseaux de neurones effectuent sur les tenseurs. C’est littéralement un flux de tenseurs. Depuis, vous avez compris ce que sont les tenseurs, avançons dans ce tutoriel TensorFlow et comprenons - qu'est-ce que TensorFlow?

Qu'est-ce que TensorFlow?

TensorFlow est une bibliothèque basée sur Python qui fournit différents types de fonctionnalités pour l'implémentation de modèles d'apprentissage profond. Comme indiqué précédemment, le terme TensorFlow est composé de deux termes - Tensor & Flow:

Dans TensorFlow, le terme tenseur fait référence à la représentation des données sous forme de tableau multidimensionnel alors que le terme flux fait référence à la série d'opérations que l'on effectue sur les tenseurs comme le montre l'image ci-dessus.

Nous avons maintenant suffisamment d'informations sur TensorFlow.

Ensuite, dans ce didacticiel TensorFlow, nous aborderons les bases du code de TensorFlow.

Tutoriel TensorFlow: principes de base du code

Fondamentalement, le processus global d'écriture d'un programme TensorFlow comprend deux étapes:

1. Construire un graphe de calcul
2. Exécution d'un graphe de calcul

Laissez-moi vous expliquer les deux étapes ci-dessus une par une:

python convertit le nombre en binaire

1. Création d'un graphe informatique

Donc, qu'est-ce qu'un graphe de calcul? Eh bien, un graphe de calcul est une série d'opérations TensorFlow organisées sous forme de nœuds dans le graphe. Chaque nœud prend 0 ou plusieurs tenseurs en entrée et produit un tenseur en sortie. Permettez-moi de vous donner un exemple de graphe de calcul simple composé de trois nœuds - à , b & c comme indiqué ci-dessous:

Explication du graphe de calcul ci-dessus:

• Nœuds constantssont utilisés pour stocker des valeurs constantes car il ne prend aucune entrée, mais produit les valeurs stockées en sortie. Dans l'exemple ci-dessus, a et b sont des nœuds constants avec les valeurs 5 et 6 respectivement.

• Le nœud c représente l'opération de multiplication du nœud constant a par b. Par conséquent, l'exécution du nœud c entraînera la multiplication des nœuds const a et b.

Fondamentalement, on peut penser à un graphe de calcul comme une autre manière de conceptualiser des calculs mathématiques qui ont lieu dans un programme TensorFlow. Les opérations affectées aux différents nœuds d'un graphe de calcul peuvent être effectuées en parallèle, offrant ainsi de meilleures performances en termes de calculs.

Ici, nous décrivons simplement le calcul, il ne calcule rien, il ne contient aucune valeur, il définit simplement les opérations spécifiées dans votre code.

2. Exécution d'un graphe de calcul

Prenons l'exemple précédent de graphe de calcul et comprenons comment l'exécuter. Voici le code de l'exemple précédent:

Exemple 1:

import tensorflow as tf # Construire un graphique a = tf.constant (5.0) b = tf.constant (6.0) c = a * b

Maintenant, pour obtenir la sortie du nœud c, nous devons exécuter le graphe de calcul dans un session . Session place les opérations de graphe sur les périphériques, tels que les CPU ou les GPU, et fournit des méthodes pour les exécuter.

Une session encapsule le contrôle et l'état du runtime TensorFlow, c'est-à-dire qu'elle stocke les informations sur l'ordre dans lequel toutes les opérations seront effectuées et transmet le résultat de l'opération déjà calculée à l'opération suivante dans le pipeline. Permettez-moi de vous montrer comment exécuter le graphique de calcul ci-dessus dans une session (l'explication de chaque ligne de code a été ajoutée en commentaire):

# Créer l'objet session sess = tf.Session () # Exécuter le graphe dans une session et stocker la sortie dans une variable output_c = sess.run (c) #Imprimer la sortie du nœud c print (output_c) #Fermer la session pour libérer des ressources sess.close ()

 Production: 30

Donc, tout était question de session et d'exécuter un graphe de calcul à l'intérieur. Parlons maintenant des variables et des espaces réservés que nous utiliserons largement lors de la création d'un modèle d'apprentissage en profondeur à l'aide de TensorFlow.

Constantes, espace réservé et variables

Dans TensorFlow, les constantes, les espaces réservés et les variables sont utilisés pour représenter différents paramètres d'un modèle d'apprentissage en profondeur. Depuis, j'ai déjà discuté des constantes plus tôt, je vais commencer par les espaces réservés.

Espace réservé:

Une constante TensorFlow vous permet de stocker une valeur, mais que se passe-t-il si vous souhaitez que vos nœuds prennent des entrées en cours d'exécution? Pour ce type de fonctionnalité, des espaces réservés sont utilisés, ce qui permet à votre graphique de prendre des entrées externes comme paramètres. Fondamentalement, un espace réservé est une promesse de fournir une valeur plus tard ou pendant l'exécution. Laissez-moi vous donner un exemple pour simplifier les choses:

import tensorflow as tf # Création d'espaces réservés a = tf. placeholder (tf.float32) b = tf. placeholder (tf.float32) # Attribution d'une opération de multiplication w.r.t. a & ampamp b au nœud mul mul = a * b # Créer un objet session sess = tf.Session () # Exécuter mul en passant les valeurs [1, 3] [2, 4] pour a et b respectivement output = sess.run ( mul, {a: [1,3], b: [2, 4]}) print ('Multiplication de ab:', sortie)

 Production: [2. 12.]

Points à retenir espaces réservés:

• Les espaces réservés ne sont pas initialisés et ne contiennent aucune donnée.
• Il faut fournir des entrées ou des flux à l'espace réservé qui sont pris en compte lors de l'exécution.
• L'exécution d'un espace réservé sans entrée génère une erreur.

Maintenant, avançons et comprenons - que sont les variables?

Variables

Dans l'apprentissage en profondeur, les espaces réservés sont utilisés pour prendre des entrées arbitraires dans votre modèle ou graphique. Outre la prise d'entrée, vous devez également modifier le graphique de manière à ce qu'il puisse produire de nouvelles sorties w.r.t. mêmes entrées. Pour cela, vous utiliserez des variables. En un mot, une variable vous permet d'ajouter de tels paramètres ou nœuds au graphique qui peuvent être entraînés, c'est-à-dire que la valeur peut être modifiée sur une période de temps. Les variables sont définies en fournissant leur valeur initiale et leur type comme indiqué ci-dessous:

var = tf.Variable ([0.4], dtype = tf.float32)

Remarque:

• Si vous n'avez pas fourni explicitement le type de données, TensorFlow déduira le type de la constante / variable à partir de la valeur initialisée.
• TensorFlow a plusieurs de ses propres types de données comme tf.float32 , tf.int32 etc. Vous pouvez vous référer à tous sur Ici .

Les constantes sont initialisées lorsque vous appelez tf.constant , et leur valeur ne peut jamais changer. Au contraire, les variables ne sont pas initialisées lorsque vous appelez tf.Variable . Pour initialiser toutes les variables d'un programme TensorFlow, vous doit appeler explicitement une opération spéciale comme indiqué ci-dessous:

init = tf.global_variables_initializer () sess.run (init)

Souvenez-vous toujours qu'une variable doit être initialisée avant qu'un graphique ne soit utilisé pour la première fois.

Remarque: Les variables TensorFlow sont des tampons en mémoire qui contiennent des tenseurs, mais contrairement aux tenseurs normaux qui ne sont instanciés que lorsqu'un graphique est exécuté et sont immédiatement supprimés par la suite, les variables survivent à travers plusieurs exécutions d'un graphique.

Maintenant que nous avons couvert suffisamment de bases de TensorFlow, allons-y et comprenons comment implémenter un modèle de régression linéaire à l'aide de TensorFlow.

Modèle de régression linéaire utilisant TensorFlow

Le modèle de régression linéaire est utilisé pour prédire la valeur inconnue d'une variable (variable dépendante) à partir de la valeur connue d'une autre variable (variable indépendante) en utilisant l'équation de régression linéaire comme indiqué ci-dessous:

Par conséquent, pour créer un modèle linéaire, vous avez besoin:

1. Variable dépendante ou de sortie (Y)
2. Variable de pente (w)
3. Y - Interception ou biais (b)
4. Variable indépendante ou d'entrée (X)

Alors, commençons à construire un modèle linéaire à l'aide de TensorFlow:

Copiez le code en cliquant sur le bouton ci-dessous:

# Création d'une variable pour la pente du paramètre (W) avec une valeur initiale de 0,4 W = tf.Variable ([. 4], tf.float32) #Création d'une variable pour le biais de paramètre (b) avec une valeur initiale de -0,4 b = tf.Variable ( [-0.4], tf.float32) # Création d'espaces réservés pour fournir une entrée ou une variable indépendante, notée xx = tf.placeholder (tf.float32) # Equation de régression linéaire linear_model = W * x + b # Initialisation de toutes les variables sess = tf.Session () init = tf.global_variables_initializer () sess.run (init) # Exécution du modèle de régression pour calculer la sortie wrt aux valeurs x fournies print (sess.run (linear_model {x: [1, 2, 3, 4]}))

Production:

qu'est-ce que le couplage lâche en java

[0. 0.40000001 0.80000007 1.20000005]

Le code indiqué ci-dessus représente simplement l'idée de base derrière la mise en œuvre du modèle de régression, c'est-à-dire comment vous suivez l'équation de la droite de régression afin d'obtenir une sortie w.r.t. un ensemble de valeurs d'entrée. Mais, il reste deux autres choses à ajouter dans ce modèle pour en faire un modèle de régression complet:

• Premièrement, nous devons fournir un mécanisme par lequel notre modèle peut s'entraîner automatiquement en fonction d'un ensemble donné d'entrées et de sorties respectives.
• La deuxième chose dont nous avons besoin est de valider notre modèle entraîné en comparant sa sortie avec la sortie souhaitée ou cible en fonction d'un ensemble donné de valeurs x.

Voyons maintenant comment puis-je incorporer les fonctionnalités énoncées ci-dessus dans mon code pour le modèle de régression.

Fonction de perte - Validation du modèle

Une fonction de perte mesure la distance entre la sortie actuelle du modèle et celle de la sortie souhaitée ou cible. J'utiliserai une fonction de perte la plus couramment utilisée pour mon modèle de régression linéaire appelée Somme des erreurs au carré ou SSE. SSE calculé w.r.t. la sortie du modèle (représentée par linear_model) et la sortie souhaitée ou cible (y) comme:

y = tf.placeholder (tf.float32) error = linear_model - y squared_errors = tf.square (error) loss = tf.reduce_sum (squared_errors) print (sess.run (loss, {x: [1,2,3,4 ], y: [2, 4, 6, 8]})

 Production: 90,24

Comme vous pouvez le voir, nous obtenons une valeur de perte élevée. Par conséquent, nous devons ajuster nos pondérations (W) et notre biais (b) afin de réduire l'erreur que nous recevons.

tAPI f.train - Formation du modèle

TensorFlow fournit optimiseurs qui modifient lentement chaque variable afin de minimiser la fonction de perte ou l'erreur. L'optimiseur le plus simple est Descente graduelle . Il modifie chaque variable en fonction de l'ampleur de la dérivée de la perte par rapport à cette variable.

#Création d'une instance de gradient descente optimizer optimizer = tf.train.GradientDescentOptimizer (0.01) train = optimizer.minimize (loss) for i in range (1000): sess.run (train, {x: [1, 2, 3, 4], y: [2, 4, 6, 8]}) impression (sess.run ([W, b]))

 Production: [tableau ([1.99999964], dtype = float32), tableau ([9.86305167e-07], dtype = float32)]

C'est ainsi que vous créez un modèle linéaire à l'aide de TensorFlow et que vous l'entraînez pour obtenir la sortie souhaitée.

Maintenant que vous connaissez le Deep Learning, consultez le par Edureka, une entreprise d'apprentissage en ligne de confiance avec un réseau de plus de 250 000 apprenants satisfaits répartis dans le monde entier. Le cours de formation Edureka Deep Learning avec certification TensorFlow aide les apprenants à devenir des experts dans la formation et l'optimisation des réseaux de neurones de base et convolutifs à l'aide de projets et d'affectations en temps réel ainsi que de concepts tels que la fonction SoftMax, les réseaux de neurones à encodeur automatique, la machine Boltzmann restreinte (RBM).

Vous avez une question pour nous? Veuillez le mentionner dans la section commentaires et nous vous recontacterons.