Article original : How to Use TensorFlow for Deep Learning – Basics for Beginners
TensorFlow est une bibliothque qui aide les ingnieurs 0 construire et entranner des modles de deep learning. Elle fournit tous les outils dont nous avons besoin pour crer des rseaux de neurones.
Nous pouvons utiliser TensorFlow pour entranner des rseaux de neurones simples ou complexes en utilisant de grands ensembles de donnes.
TensorFlow est utilis dans une varit d'applications, de la reconnaissance d'images et de la parole au traitement du langage naturel et 0 la robotique. TensorFlow nous permet de construire rapidement et facilement des modles d'IA puissants avec une grande prcision et performance.
TensorFlow fonctionne 9galement avec des GPU et des TPU, qui sont des types de puces informatiques conues pour 9tendre les capacits de TensorFlow. Ces puces permettent 0 TensorFlow de fonctionner plus rapidement, ce qui est utile lorsque vous avez beaucoup de donnes 0 traiter.
Dans cet article, nous allons apprendre ce que sont les tenseurs et comment travailler avec eux en utilisant TensorFlow. Plongeons-nous directement dans le sujet.
Qu'est-ce qu'un tenseur ?
Une explication simple serait qu'un tenseur est un tableau multi-dimensionnel.
Scalaire, Vecteur, Matrice et Tenseur
Un scalaire est un nombre unique. Un vecteur est un tableau de nombres. Une matrice est un tableau 0 deux dimensions. Un tenseur est un tableau 0 n dimensions.
Dans TensorFlow, tout peut atre considr comme un tenseur, y compris un scalaire. Un scalaire serait un tenseur de dimension 0, un vecteur de dimension 1, et une matrice de dimension 2.
Cela est utile car nous ne sommes pas limits 0 travailler avec des ensembles de donnes complexes dans TensorFlow. TensorFlow peut grer tout type de donnes et les alimenter dans des modles de machine learning.
Qu'est-ce que TensorFlow ?
TensorFlow est une bibliothque logicielle open-source pour la construction de rseaux de neurones. L'9quipe Google Brain est celle qui l'a dveloppe et c'est la bibliothque de deep learning la plus populaire sur le marche aujourd'hui.
Vous pouvez utiliser TensorFlow pour construire des modles d'IA, y compris la reconnaissance d'images et de la parole, le traitement du langage naturel et la mod9lisation pr9dictive.
R9seau de neurones de classification
TensorFlow utilise un graphe de flux de donnes pour repr9senter les calculs. Pour faire simple, TensorFlow a facilit la construction de modles de machine learning complexes.
TensorFlow g9re beaucoup de travail en coulisses, ce qui le rend utile lors de la construction et de l'entraînement de tout type de mod9le de machine learning. TensorFlow g9re 9galement les calculs, y compris la parall9lisation et l'optimisation, au nom de l'utilisateur.
TensorFlow et Keras
TensorFlow et Keras
TensorFlow dispose d'une API de haut niveau appele Keras. Keras 9tait un projet autonome qui est maintenant disponible dans la bibliothque TensorFlow. Keras facilite la dfinition et l'entraînement des mod9les tandis que TensorFlow offre un contr4le plus pouss9 sur les calculs.
TensorFlow prend en charge une large gamme de mat9riel, y compris les CPU, les GPU et les TPU. Les TPU sont des unites de traitement de tenseurs, con7ues sp9cifiquement pour travailler avec les tenseurs et TensorFlow.
Nous pouvons 9galement ex9cuter TensorFlow sur des appareils mobiles et des appareils IoT en utilisant TensorFlow Lite. TensorFlow dispose 9galement d'une grande communaut9 de d9veloppeurs et est mis 0 jour avec de nouvelles fonctionnalites et capacites.
Comment construire des tenseurs avec TensorFlow
Commen7ons 0 9crire du code. Si vous n'avez pas TensorFlow install9, vous pouvez utiliser un Google colab notebook pour suivre.
Commen7ons par importer TensorFlow et afficher la version.
import tensorflow as tf
print(tf.__version__)
OUTPUT:
2.9.2
Commen7ons par cr9er un scalaire en utilisant tf.constant. Nous utilisons tf.constant pour cr9er une nouvelle valeur constante. Nous pouvons 9galement utiliser tf.variable pour cr9er une valeur variable. Nous allons ensuite afficher la valeur et v9rifier la dimension du scalaire en utilisant la propri9t9 ndim. Sa dimension sera z9ro car il s'agit d'une seule valeur.
scalar = tf.constant(7)
print(scalar)
print(scalar.ndim)
OUTPUT:
tf.Tensor(7, shape=(), dtype=int32)
0
Maintenant, cr9ons un vecteur et affichons ses dimensions. Vous pouvez voir que la dimension est 1.
vector = tf.constant([10,10])
print(vector)
print(vector.ndim)
OUTPUT:
tf.Tensor([10 10], shape=(2,), dtype=int32)
1
Maintenant, essayons de cr9er une matrice et d'afficher ses dimensions.
matrix = tf.constant([
[10,11],
[12,13]
])
print(matrix)
print(matrix.ndim)
OUTPUT:
tf.Tensor(
[[10 11]
[12 13]], shape=(2, 2), dtype=int32)
2
Vous verrez que la dimension est maintenant 2. Vous pouvez 9galement voir que la forme de la matrice est 2 par 2.
Les formes et les dimensions sont utiles lors de l'utilisation de TensorFlow car nous changerons souvent ces donnes lors de l'utilisation de ces donnes pour entranner des rseaux de neurones.
Nous avons vu que ces tenseurs ont un type de donnes par dfaut de int32. Que faire si nous voulons cr9er un ensemble de donnes avec un type de donnes personnalis9 ?
tf.constant nous fournit l'argument dtype. Cr9ons la m9me matrice 0 nouveau avec float16 comme type de donnes.
tensor_1 = tf.constant([
[
[1,2,3]
],
[
[4,5,6]
],
[
[7,8,9]
]
],dtype='float32')
print(tensor_1)
OUTPUT:
tf.Tensor(
[[[1. 2. 3.]]
[[4. 5. 6.]]
[[7. 8. 9.]]], shape=(3, 1, 3), dtype=float32)
Maintenant, cr9ons un tenseur. Nous allons entrer un tableau 0 trois dimensions dans tf.constant. Nous allons 9galement afficher ses dimensions.
tensor = tf.constant([
[
[1,2,3]
],
[
[4,5,6]
],
[
[7,8,9]
]
])
print(tensor)
print(tensor.ndim)
OUTPUT:
tf.Tensor(
[[[1 2 3]]
[[4 5 6]]
[[7 8 9]]], shape=(3, 1, 3), dtype=int32)
3
Nous avons maintenant un tenseur de dimension 3 et de forme 3 par 1 par 3. C'est le tenseur le plus simple que vous puissiez cr9er. Dans des scnarios r9els, nous traiterons des tenseurs de dimensions sup9rieures et de formes plus grandes.
Maintenant, voyons comment cr9er un tenseur variable. Nous n'utiliserons pas souvent de tenseurs variables par rapport aux tenseurs constants, mais il est bon de savoir que nous avons une option.
Nous utiliserons tf.Variable pour cr9er un tenseur variable. La diff9rence entre le tenseur constant et le tenseur variable est que vous pouvez changer les donnes dans un tenseur variable, mais vous ne pouvez pas changer les valeurs dans un tenseur constant. Cr9ons un tenseur variable et affichons les dimensions.
var_tensor = tf.Variable([
[
[1,2,3]
],
[
[4,5,6]
],
[
[7,8,9]
]
])
print(var_tensor)
OUTPUT:
<tf.Variable 'Variable:0' shape=(3, 1, 3) dtype=int32, numpy=
array([[[1, 2, 3]],
[[4, 5, 6]],
[[7, 8, 9]]], dtype=int32)>
Comment g9n9rer et charger des tenseurs
Voyons comment g9n9rer des tenseurs. Dans la plupart des cas, vous ne cr9erez pas de tenseurs 0 partir de z9ro. Vous chargerez soit un ensemble de donnes, convertirez d'autres ensembles de donnes comme des tableaux NumPy en tenseurs, ou g9n9rerez des tenseurs. Commen7ons par voir comment g9n9rer des tenseurs.
Cr9ons un tenseur avec des valeurs al9atoires. Il existe deux fa7ons courantes de le faire : g9n9rer une distribution normale de donnes ou une distribution uniforme de donnes.
Distribution normale
La distribution normale est une courbe en forme de cloche qui repr9sente la distribution des donnes. La plupart des donnes seront proches de la moyenne et moins de donnes seront 9loignes de la moyenne. Cela signifie que la probabilit9 d'obtenir une valeur proche de la moyenne est plus 9leve.
Distribution uniforme
La distribution uniforme est une ligne droite qui repr9sente la distribution des donnes. Toutes les valeurs dans une distribution uniforme auront une probabilit9 9gale de se produire dans une plage donne.
Avant de g9n9rer des valeurs al9atoires, vous devez comprendre ce qu'est une graine. Si nous utilisons une valeur de graine, nous pouvons reg9n9rer le m9me ensemble de donnes plusieurs fois. Cela sera utile lorsque nous voudrons tester notre mod9le de machine learning contre les m9mes donnes apr9s avoir ajust9 ses performances.
Cr9ons deux tableaux de tenseurs al9atoires. Nous allons d'abord d9finir une graine et g9n9rer les valeurs al9atoires en utilisant cette graine.
seed = tf.random.Generator.from_seed(42)
Maintenant, nous allons cr9er une distribution normale et uniforme avec la forme 3 par 2.
normal_tensor = seed.normal(shape=(3,2))
print(normal_tensor)
uniform_tensor = seed.uniform(shape=(3,2))
print(uniform_tensor)
OUTPUT:
tf.Tensor( [[-0.7565803 -0.06854702] [ 0.07595026 -1.2573844 ] [-0.23193765 -1.8107855 ]], shape=(3, 2), dtype=float32)
tf.Tensor( [[0.7647915 0.03845465] [0.8506975 0.20781887] [0.711869 0.8843919 ]], shape=(3, 2), dtype=float32)
Nous avons cr99 deux tenseurs, l'un avec une distribution normale de nombres al9atoires et l'autre avec une distribution uniforme de nombres al9atoires.
Ensuite, nous allons cr9er un tenseur avec des z9ros et des uns. Dans TensorFlow, les tenseurs remplis de z9ros ou de uns sont souvent utilis9s comme point de d9part pour cr9er d'autres tenseurs. Ils peuvent 9galement atre des espaces r9serv9s pour les entr9es dans un graphe de calcul.
Pour cr9er un tenseur de z9ros, utilisez la fonction tf.zeros avec une forme comme argument d'entre. Pour cr9er un tenseur avec des uns, nous utilisons tf.ones avec la forme comme argument d'entre.
zeros = tf.zeros(shape=(3,2))
print(zeros)
ones = tf.ones(shape=(3,2))
print(ones)
OUTPUT:
tf.Tensor(
[[0. 0.]
[0. 0.]
[0. 0.]], shape=(3, 2), dtype=float32)
tf.Tensor(
[[1. 1.]
[1. 1.]
[1. 1.]], shape=(3, 2), dtype=float32)
Maintenant, voyons comment convertir des tableaux NumPy en tenseurs. Si vous ne savez pas ce qu'est NumPy, c'est une biblioth9que Python pour le calcul num9rique. Elle nous aide 0 g9rer de grands ensembles de donnes et 0 effectuer une vari9t9 de calculs sur eux.
Importons NumPy et cr9ons un tableau NumPy en utilisant la fonction arrange de NumPy.
import numpy as np
numpy_arr = np.arange(1,25,dtype=np.int32)
Maintenant, nous pouvons cr9er un tenseur en utilisant la fonction tf.constant avec le tableau NumPy comme entre. TensorFlow a un support int9gr9 pour g9rer les tableaux NumPy, donc il suffit d'importer un tableau NumPy et de d9finir une forme.
print(numpy_arr)
numpy_tensor = tf.constant(numpy_arr,shape=[2,4,3])
print(numpy_tensor)
OUTPUT:
[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
tf.Tensor(
[[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]
[[13 14 15]
[16 17 18]
[19 20 21]
[22 23 24]]], shape=(2, 4, 3), dtype=int32)
Vous pouvez voir 0 la fois le tableau NumPy ainsi que notre tenseur. Le tableau NumPy original 9tait de 1x12 mais notre tenseur est de 2x4x3. Cela s'appelle le remodelage d'un tenseur, que nous ferons souvent lors de l'entraînement de rseaux de neurones profonds.
Op9rations de base utilisant TensorFlow
Nous avons appris comment les tenseurs sont cr99s dans TensorFlow. Maintenant, voyons quelques op9rations de base utilisant des tenseurs.
Nous allons commencer par obtenir quelques informations sur nos tenseurs. Cr9ons un tenseur 4D avec des valeurs 0 avec la forme 2x3x4x5.
rank4_tensor = tf.zeros([2,3,4,5])
print(rank4_tensor)
OUTPUT:
tf.Tensor(
[[[[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]
[[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]
[[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]]
[[[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]
[[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]
[[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]]], shape=(2, 3, 4, 5), dtype=float32)
Nous avons cr99 notre tenseur de rang 4. Maintenant, obtenons quelques informations sur la taille, la forme (nombre de valeurs) et la dimension du tenseur.
Nous utiliserons la fonction tf.size pour obtenir la taille. Les propri9t9s shape et ndim nous donneront la forme et les dimensions du tenseur.
print("Size",tf.size(rank4_tensor))
print("shape",rank4_tensor.shape)
print("Dimension",rank4_tensor.ndim)
OUTPUT:
Size tf.Tensor(120, shape=(), dtype=int32)
shape (2, 3, 4, 5)
Dimension 4
Regardons quelques calculs simples en utilisant le tenseur. Je vais cr9er un nouveau tenseur de base.
basic_tensor = tf.constant([[10,11],[12,13]])
print(basic_tensor)
OUTPUT:
tf.Tensor(
[[10 11]
[12 13]], shape=(2, 2), dtype=int32)
Essayons quelques op9rations simples. Nous pouvons ajouter, soustraire, multiplier et diviser chaque valeur dans un tenseur en utilisant les op9rateurs de base.
print(basic_tensor + 10)
print(basic_tensor - 10)
print(basic_tensor * 10)
print(basic_tensor / 10)
OUTPUT:
tf.Tensor(
[[20 21]
[22 23]], shape=(2, 2), dtype=int32)
tf.Tensor(
[[0 1]
[2 3]], shape=(2, 2), dtype=int32)
tf.Tensor(
[[100 110]
[120 130]], shape=(2, 2), dtype=int32)
tf.Tensor(
[[1. 1.1]
[1.2 1.3]], shape=(2, 2), dtype=float64)
Maintenant, essayons la multiplication de matrices. Je vais cr9er deux tenseurs simples tensor_011 et tensor_012.
tensor_011 = tf.constant([[2,2],[4,4]])
tensor_012 = tf.constant([[2,3],[4,5]])
Gardez 0 l'esprit que dans la multiplication de matrices, les dimensions int9rieures doivent correspondre. Par exemple, une multiplication (3, 5) (3, 5) ne fonctionnera pas, mais (3, 5) (5, 3) fonctionnera.
La forme finale de la matrice r9sultante sera sa dimension ext9rieure. Donc, un tenseur 3x5 multipli9 par un tenseur 5x3 nous donnera un tenseur 5x5. Nous utiliserons la fonction tf.matmul pour effectuer la multiplication de matrices.
print(tf.matmul(tensor_011,tensor_012))
OUTPUT:
tf.Tensor(
[[12 16]
[24 32]], shape=(2, 2), dtype=int32)
Ensuite, regardons le remodelage et la transposition d'une matrice. Comme nous l'avons vu auparavant, nous utiliserons souvent le remodelage pour changer la structure de notre matrice lors de l'entraînement de rseaux de neurones.
Par exemple, une matrice de pixels d'image de 28x28 sera convertie en un tableau de pixels 0 une dimension de 784 pour un rseau de neurones de classification d'images.
Pour remodeler, nous utilisons la fonction tf.reshape. Pour transposer, nous utilisons la fonction tf.transpose. Si vous ne savez pas ce qu'est une transpose, c'est la conversion des lignes en colonnes et des colonnes en lignes.
print(tf.reshape(tensor_011,[4,1]))
print(tf.transpose(tensor_011))
OUTPUT:
tf.Tensor(
[[2]
[2]
[4]
[4]], shape=(4, 1), dtype=int32)
tf.Tensor(
[[2 4]
[2 4]], shape=(2, 2), dtype=int32)
Enfin, regardons quelques op9rations d'agr9gation comme min, max, 9cart-type, carr9 et racine carre.
Pour trouver les valeurs minimale et maximale, nous utilisons les fonctions tf.reduce_min et tf.reduce_max. Et pour trouver la somme du tableau, nous utilisons la fonction tf.reduce_sum.
tensor_013 = tf.constant([
[1,2,3],
[4,5,6],
[7,8,9]
],dtype='float32')
print(tf.reduce_min(tensor_013))
print(tf.reduce_max(tensor_013))
print(tf.reduce_sum(tensor_013))
OUTPUT:
tf.Tensor(1.0, shape=(), dtype=float32)
tf.Tensor(9.0, shape=(), dtype=float32)
tf.Tensor(45.0, shape=(), dtype=float32)
Maintenant, pour l'9cart-type et la variance, nous utilisons la fonction tf.math.reduce_std et la fonction tf.math.reduce_variance.
print(tf.math.reduce_std(tensor_013))
print(tf.math.reduce_variance(tensor_013))
OUTPUT:
tf.Tensor(2.5819888, shape=(), dtype=float32)
tf.Tensor(6.6666665, shape=(), dtype=float32)
Trouvons le carr9, la racine carre et le logarithme de chaque valeur dans un tenseur.
print(tf.sqrt(tensor_013))
print(tf.square(tensor_013))
print(tf.math.log(tensor_013))
OUTPUT:
tf.Tensor(
[[1. 1.4142135 1.7320508]
[2. 2.236068 2.4494898]
[2.6457512 2.828427 3. ]], shape=(3, 3), dtype=float32)
tf.Tensor(
[[ 1. 4. 9.]
[16. 25. 36.]
[49. 64. 81.]], shape=(3, 3), dtype=float32)
tf.Tensor(
[[0. 0.6931472 1.0986123]
[1.3862944 1.609438 1.7917595]
[1.9459102 2.0794415 2.1972246]], shape=(3, 3), dtype=float32)
Nous avons appris les bases de TensorFlow dans cet article. Vous ates maintenant 9quip9 pour travailler avec TensorFlow et l'utiliser pour mod9liser des donnes.
Si vous souhaitez commencer 0 utiliser ces connaissances et construire un projet, vous pouvez consulter mon cours sur la construction d'un rseau de neurones de reconnaissance d'9criture 0 la main en utilisant TensorFlow. Vous pouvez 9galement apprendre des concepts avanc9s de TensorFlow en utilisant la documentation officielle.
Conclusion
TensorFlow est une biblioth9que puissante pour construire des mod9les de deep learning. Elle dispose de tous les outils dont nous avons besoin pour construire des rseaux de neurones afin de r9soudre des probl9mes comme la classification d'images, l'analyse des sentiments, les pr9dictions du march9 boursier, etc.
Avec l'av8nement de technologies comme ChatGPT, apprendre TensorFlow vous donnera une longueur d'avance sur le march9 du travail actuel.
J'esp8re que vous avez aim9 cet article. Vous pouvez en apprendre plus sur moi et mes articles/vid9os sur manishmshiva.com.