Qu'est-ce que TensorFlow ? Comment ça marche ? ArchiStructure et fonctionnalités

Qu'est-ce que TensorFlow ?

TensorFlow est une plateforme open source de bout en bout pour créer des applications de Machine Learning. Il s'agit d'une bibliothèque mathématique symbolique qui utilise le flux de données et la programmation différenciable pour effectuer diverses tâches axées sur la formation et l'inférence de réseaux neuronaux profonds. Il permet aux développeurs de créer des applications d'apprentissage automatique à l'aide de divers outils, bibliothèques et ressources communautaires.

Actuellement, la bibliothèque d'apprentissage profond la plus célèbre au monde est GoogleTensorFlow de 's. Google Elle utilise l'apprentissage automatique dans l'ensemble de ses produits pour améliorer la recherche, la traduction, la légende d'images et les recommandations.

Exemple TensorFlow

Pour donner un exemple concret, Google Grâce à l'IA, les utilisateurs bénéficient d'une expérience de recherche plus rapide et plus précise. Si l'utilisateur saisit un mot-clé dans la barre de recherche, Google propose une suggestion quant au mot suivant.

Google souhaite utiliser l'apprentissage automatique pour tirer parti de ses vastes ensembles de données et offrir aux utilisateurs la meilleure expérience possible. Trois groupes différents utilisent l'apprentissage automatique :

• et de recherche
• Data Scientists
• Programmeurs

Ils peuvent tous utiliser le même ensemble d’outils pour collaborer les uns avec les autres et améliorer leur efficacité.

Google Ce système ne se contente pas de stocker de vastes ensembles de données, il gère également une infrastructure de calcul colossale ; c’est pourquoi TensorFlow a été conçu dès le départ pour assurer une montée en charge. TensorFlow est une bibliothèque développée par… Google Une équipe dédiée au cerveau pour accélérer la recherche sur l'apprentissage automatique et les réseaux neuronaux profonds.

Il a été conçu pour fonctionner sur plusieurs processeurs ou GPU et même sur des systèmes d'exploitation mobiles, et il dispose de plusieurs wrappers dans plusieurs langages comme Python, C++ or Java.

Histoire de TensorFlow

Il y a quelques années, l'apprentissage profond a commencé à surpasser tous les autres algorithmes d'apprentissage automatique lorsqu'on lui fournissait une quantité massive de données. Google elle a compris qu'elle pouvait utiliser ces réseaux neuronaux profonds pour améliorer ses services :

• Gmail
• linkedin IA
• Google moteur de recherche

Ils ont construit un cadre appelé TensorFlow afin que les chercheurs et les développeurs puissent travailler sur le même modèle, puis le déployer à une échelle utilisable par un grand nombre de personnes.

TensorFlow a été rendu public en novembre 2015, et la version 1.0 a suivi en février 2017. Le changement bien plus important est survenu avec TensorFlow 2.0 en septembre 2019, ce qui a fait de l'exécution immédiate le comportement par défaut et a adopté Keras comme API de haut niveau standard. À partir de la version 2.16, Keras 3 est le modèle par défaut, et le même code de modèle peut également s'exécuter sur JAX ou Py.Torch backends.

TensorFlow est distribué sous licence Apache 2.0 ; vous pouvez donc l’utiliser, le modifier et le redistribuer, y compris à des fins commerciales, sans payer. Google.

Comment fonctionne TensorFlow

TensorFlow vous permet de créer des graphiques et des structures de flux de données pour définir la manière dont les données se déplacent dans un graphique en prenant les entrées sous la forme d'un tableau multidimensionnel appelé Tensor. Il vous permet de construire un organigramme des opérations pouvant être effectuées sur ces entrées, qui va à une extrémité et arrive à l'autre extrémité en sortie.

TensorFlow Architecture

L'architecture de TensorFlow fonctionne en trois parties :

• Prétraitement des données
• Construisez le modèle
• Entraîner et estimer le modèle

Il est appelé TensorFlow car il prend en entrée un tableau multidimensionnel, également appelé tenseurs. Vous pouvez construire une sorte de Organigramme d'opérations (appelées graphique) que vous souhaitez effectuer sur cette entrée. L’entrée entre par une extrémité, puis traverse ce système d’opérations multiples et ressort par l’autre extrémité en tant que sortie.

Où TensorFlow peut-il s'exécuter ?

Les exigences matérielles et logicielles de TensorFlow se divisent en deux phases :

Phase de développement: c'est à ce moment-là que vous entraînez le modèle, généralement sur un ordinateur de bureau ou un ordinateur portable.

Phase d'exécution ou d'inférenceUne fois l'entraînement terminé, le modèle peut fonctionner sur de nombreuses plateformes :

• Bureau en cours d'exécution Windows, macOS ou Linux
• Le cloud en tant que service Web
• Appareils mobiles comme iOS et Android

Vous pouvez l'entraîner sur plusieurs machines, puis l'exécuter sur une autre machine, une fois que vous avez le modèle entraîné.

Le modèle peut être entraîné et utilisé aussi bien sur GPU que sur CPU. Les GPU ont été initialement conçus pour les jeux vidéo. Vers 2009, des chercheurs de Stanford ont démontré leur extrême efficacité pour les opérations matricielles et d'algèbre linéaire dont dépendent les réseaux de neurones. L'apprentissage profond repose en effet sur de nombreuses multiplications matricielles. TensorFlow est très rapide pour effectuer ces multiplications car il est écrit en C++. Bien qu'il soit mis en œuvre dans C++, TensorFlow est accessible et contrôlé par d'autres langages principalement, Python.

Une autre caractéristique importante est Tableau Tenseur, qui visualise le graphique, les métriques d'entraînement et la distribution des poids pendant l'exécution du modèle.

Composants TensorFlow

tenseur

Le nom de TensorFlow est directement dérivé de son framework principal : tenseurDans TensorFlow, tous les calculs impliquent des tenseurs. Un tenseur est un… vecteur or matrice de n dimensions qui représente tous les types de données. Toutes les valeurs d'un tenseur contiennent un type de données identique avec un type de données connu (ou partiellement connu) forme. La forme des données correspond à la dimensionnalité de la matrice ou du tableau.

Un tenseur peut provenir des données d'entrée ou du résultat d'un calcul. Dans TensorFlow, toutes les opérations sont effectuées au sein d'un graphique. Le graphe est un ensemble de calculs qui s'effectuent successivement. Chaque opération est appelée une nœud opérationnel et sont connectés les uns aux autres.

Le graphique décrit les opérations et les connexions entre les nœuds. Cependant, il n'affiche pas les valeurs. Le bord des nœuds est le tenseur, c'est-à-dire un moyen de remplir l'opération avec des données.

Graphiques

TensorFlow utilise un framework graphique. Le graphique rassemble et décrit tous les calculs de séries effectués lors de la formation. Le graphique présente de nombreux avantages :

• Il fonctionne sur plusieurs processeurs ou cartes graphiques, et même sur des systèmes d'exploitation mobiles.
• La portabilité du graphe permet de conserver les calculs pour une utilisation immédiate ou ultérieure. Le graphique peut être enregistré pour être exécuté ultérieurement.
• Tous les calculs du graphique sont effectués en connectant des tenseurs entre eux
  • Un graphe est composé de nœuds et d'arêtes. Chaque nœud représente une opération mathématique et produit une sortie, tandis que les arêtes décrivent les relations d'entrée et de sortie entre les nœuds. Les tenseurs se déplacent le long des arêtes.

Pourquoi TensorFlow est-il populaire ?

TensorFlow est largement adopté car il est accessible à tous les niveaux d'expertise. Ses API couvrent tous les besoins, d'un modèle Keras de trois lignes à un CNN ou RNN conçu manuellement. Le calcul étant représenté sous forme de graphe, TensorBoard permet de visualiser le réseau et de simplifier considérablement le débogage. Il se déploie également à grande échelle, fonctionnant sur CPU, GPU et TPU, ainsi que sur mobile grâce à TensorFlow Lite.

TensorFlow reste l'un des deux frameworks d'apprentissage profond les plus utilisés sur GitHub, aux côtés de Py.Torch.

TensorFlow Algorithms

TensorFlow intègre des estimateurs de haut niveau pour plusieurs algorithmes classiques. Dans TensorFlow 1.x, ceux-ci se trouvaient sous le nom de tf.estimator :

• Régression linéaire : tf.estimator.LinearRegressor
• Classification : tf.estimator.LinearClassifier
• Classification de l'apprentissage profond : tf.estimator.DNNClassifier
• Apprentissage étendu et approfondi : tf.estimator.DNNLinearCombinedClassifier
• Régression par arbres de décision boostés : tf.estimator.BoostedTreesRegressor
• Classification des arbres boostée : tf.estimator.BoostedTreesClassifier

TensorFlow contre PyTorch : Lequel choisir ?

TensorFlow et PyTorCe sont les deux principaux frameworks d'apprentissage profond, et les différences pratiques se sont considérablement réduites depuis que TensorFlow 2.0 a adopté l'exécution immédiate.

La réponse pragmatique : choisissez TensorFlow lorsque le modèle doit être déployé sur mobile, navigateur ou plateforme de diffusion gérée, et choisissez Python.Torch lors de l'itération sur l'architecture du modèle. Keras 3, le système par défaut à partir de TensorFlow 2.16, atténue encore ce choix, car le même code Keras peut s'exécuter sur TensorFlow, JAX ou PyTorch backend.

Fonctionnement des calculs dans TensorFlow

import numpy as np
import tensorflow as tf

Dans les deux premières lignes de code, nous avons importé Tensorflow au format tf. Avec Python, il est courant d'utiliser un nom court pour une bibliothèque. L'avantage est d'éviter de taper le nom complet de la bibliothèque lorsqu'on a besoin de l'utiliser. Par exemple, nous pouvons importer Tensorflow au format tf et appeler tf lorsque nous voulons utiliser une fonction Tensorflow.

Entraînons-nous aux principes de base de TensorFlow à l'aide d'exemples simples. Créons un graphe de calcul qui multiplie deux nombres.

Dans cet exemple, nous allons multiplier X_1 et X_2. TensorFlow créera un nœud pour effectuer cette opération. Dans notre exemple, ce nœud est nommé « multiply ». Une fois le graphe déterminé, les moteurs de calcul de TensorFlow multiplieront X_1 et X_2.

Enfin, nous exécuterons une session TensorFlow qui exécutera le graphique de calcul avec les valeurs de X_1 et X_2 et imprimera le résultat de la multiplication.

Définissons les nœuds d'entrée X_1 et X_2. Lors de la création d'un nœud dans TensorFlow, il est nécessaire de choisir son type. Les nœuds X1 et X2 seront des nœuds de substitution. Ces nœuds se voient attribuer une nouvelle valeur à chaque calcul. Nous les créerons donc en tant que nœuds de substitution TF.

Étape 1 : Définir la variable

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

Un espace réservé nécessite un type de données. Il s'agit ici de nombres ; `tf.float32` est donc le choix approprié. L'argument `name` est facultatif, mais utile, car il correspond à l'étiquette qui apparaît dans la visualisation du graphique sur TensorBoard. `X_2` est défini de la même manière.

Étape 2 : Définir le calcul

multiply = tf.multiply(X_1, X_2, name = "multiply")

Nous pouvons maintenant définir le nœud qui effectue l'opération de multiplication. Dans TensorFlow, cela se fait en créant un nœud tf.multiply.

Nous passerons les nœuds X_1 et X_2 au nœud de multiplication. Il demande à Tensorflow de lier ces nœuds dans le graphe informatique, nous lui demandons donc d'extraire les valeurs de x et y et de multiplier le résultat. Donnons également au nœud de multiplication le nom de multiplication. C'est la définition complète de notre graphe informatique simple.

Étape 3 : Exécuter l'opération

Pour exécuter des opérations sur le graphe, il faut créer une session. Dans TensorFlow, cela se fait avec `tf.Session()`. Une fois la session créée, on peut lui demander d'exécuter des opérations sur le graphe de calcul en appelant `session`. Pour lancer le calcul, il faut utiliser `run`.

Lors de l'exécution de l'opération de multiplication, les valeurs des nœuds X_1 et X_2 sont nécessaires ; il faut donc les fournir au moment de l'exécution. Pour ce faire, on utilise le paramètre feed_dict. On transmet les valeurs 1, 2, 3 pour X_1 et 4, 5, 6 pour X_2.

Nous imprimons les résultats avec print(result). On devrait voir 4, 10 et 18 pour 1×4, 2×5 et 3×6

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

multiply = tf.multiply(X_1, X_2, name = "multiply")

with tf.Session() as session:
    result = session.run(multiply, feed_dict={X_1:[1,2,3], X_2:[4,5,6]})
    print(result)

[ 4. 10. 18.]

Options pour charger des données dans TensorFlow

La première étape avant de former un algorithme d'apprentissage automatique Il s'agit de charger les données. Il existe deux méthodes courantes pour charger des données :

1. Charger des données en mémoireC'est la méthode la plus simple. Vous chargez toutes vos données en mémoire sous forme d'un seul tableau. Vous écrivez simplement Python Pour cela, rien n'est spécifique à TensorFlow.

2. pipeline de données TensorFlowTensorFlow fournit une API intégrée qui charge les données, applique des transformations et alimente le modèle. Cette méthode est particulièrement efficace avec les grands ensembles de données. Par exemple, les enregistrements d'images sont connus pour être volumineux et ne tiennent pas en mémoire. Le pipeline de données gère la mémoire de manière autonome.

Quelle solution utiliser ?

Charger des données en mémoire

Si votre ensemble de données n'est pas trop volumineux, c'est-à-dire moins de 10 gigaoctets, vous pouvez utiliser la première méthode. Les données peuvent tenir dans la mémoire. Vous pouvez utiliser une célèbre bibliothèque appelée Pandas pour importer des fichiers CSV. Vous en apprendrez plus sur les pandas dans le prochain tutoriel.

Charger les données avec le pipeline TensorFlow

La deuxième méthode fonctionne mieux si vous disposez d’un grand ensemble de données. Par exemple, si vous disposez d’un ensemble de données de 50 Go et que votre ordinateur ne dispose que de 16 Go de mémoire, la machine plantera.

Dans ce cas, il est nécessaire de créer un pipeline TensorFlow. Ce pipeline chargera les données par lots, ou petits blocs. Chaque lot sera traité par le pipeline et prêt pour l'entraînement. La création d'un pipeline est une excellente solution car elle permet d'utiliser le calcul parallèle. Concrètement, TensorFlow entraînera le modèle sur plusieurs cœurs de processeur. Cela accélère les calculs et rend possible l'entraînement de réseaux plus vastes.

En résumé : chargez de petits ensembles de données en mémoire avec pandas, et utilisez un pipeline TensorFlow lorsque les données sont volumineuses ou lorsque vous souhaitez un chargement parallèle sur plusieurs processeurs.

Comment créer un pipeline TensorFlow

Voici les étapes pour créer un pipeline TensorFlow :

Dans l'exemple précédent, nous avons ajouté manuellement trois valeurs pour X_1 et X_2. Nous allons maintenant voir comment charger des données dans TensorFlow :

Étape 1) Créer les données

Tout d'abord, utilisons la bibliothèque numpy pour générer deux valeurs aléatoires.

import numpy as np
x_input = np.random.sample((1,2))
print(x_input)

[[0.8835775 0.23766977]]

Étape 2) Créez l'espace réservé

Comme dans l'exemple précédent, nous créons un espace réservé avec le nom X. Nous devons spécifier explicitement la forme du tenseur. Dans ce cas, nous chargerons un tableau avec seulement deux valeurs. Nous pouvons écrire la forme sous la forme shape=[1,2]

# using a placeholder
x = tf.placeholder(tf.float32, shape=[1,2], name = 'X')

Étape 3) Définir la méthode de jeu de données

Ensuite, nous devons définir l'ensemble de données dans lequel nous pouvons renseigner la valeur de l'espace réservé x. Nous devons utiliser la méthode tf.data.Dataset.from_tensor_slices

dataset = tf.data.Dataset.from_tensor_slices(x)

Étape 4) Créer le pipeline

À la quatrième étape, nous devons initialiser le pipeline dans lequel les données circuleront. Nous devons créer un itérateur avec make_initializing_iterator. Nous l'appelons itérateur. Ensuite, nous devons appeler cet itérateur pour alimenter le prochain lot de données, get_next. Nous nommons cette étape get_next. Notez que dans notre exemple, il n'y a qu'un seul lot de données avec seulement deux valeurs.

iterator = dataset.make_initializable_iterator() 
get_next = iterator.get_next()

Étape 5) Exécuter l'opération

La dernière étape est similaire à l'exemple précédent. Nous lançons une session et exécutons l'itérateur d'opération. Nous alimentons le feed_dict avec la valeur générée par numpy. Ces deux valeurs rempliront l'espace réservé x. Ensuite, nous exécutons get_next pour imprimer le résultat.

with tf.Session() as sess:
    # feed the placeholder with data
    sess.run(iterator.initializer, feed_dict={ x: x_input }) 
    print(sess.run(get_next))

[0.8835775  0.23766978]

TensorFlow 1.x vs TensorFlow 2.x : Quelles différences ?

TensorFlow 2.0 a constitué une refonte majeure de l'API utilisateur. Il est important de comprendre cette différence, car de nombreux tutoriels en ligne, y compris les exemples ci-dessus, sont basés sur le style de la version 1.x.

L'exemple de multiplication, réécrit. Trois étapes et une session se transforment en une seule ligne, car l'opération s'exécute dès qu'elle est appelée :

import tensorflow as tf

X_1 = tf.constant([1, 2, 3], dtype=tf.float32)
X_2 = tf.constant([4, 5, 6], dtype=tf.float32)

result = tf.multiply(X_1, X_2, name="multiply")
print(result.numpy())        # [ 4. 10. 18.]

Le pipeline d'entrée, réécrit. Aucun espace réservé ni objet itérateur ne sont requis :

import numpy as np
import tensorflow as tf

x_input = np.random.sample((1, 2))
dataset = tf.data.Dataset.from_tensor_slices(x_input)

for batch in dataset:
    print(batch.numpy())

Si vous avez besoin de la vitesse d'un graphe compilé, encapsulez la fonction dans @tf.function et TensorFlow. tracIl est automatiquement converti en un seul. Les scripts 1.x hérités peuvent également être exécutés sans modification via l'espace de noms tf.compat.v1, mais ce chemin est réservé à la maintenance et ne doit pas être utilisé pour de nouveaux développements.

TensorFlow : Points clés et Code Références

• Signification de TensorFlow : TensorFlow est la bibliothèque d'apprentissage profond la plus célèbre de ces dernières années. Un praticien utilisant TensorFlow peut créer n'importe quelle structure d'apprentissage en profondeur, comme CNN, RNN ou un simple réseau de neurones artificiels.
• TensorFlow est principalement utilisé par les universitaires, les startups et les grandes entreprises. Google utilise TensorFlow dans presque tous les cas Google produits de consommation courante, y compris Gmail, Photo et Google Moteur de recherche.
• Le Google L'équipe Brain a développé TensorFlow pour faciliter la collaboration entre les chercheurs et les développeurs de produits. En 2015, elle a rendu TensorFlow public ; sa popularité croît rapidement. Aujourd'hui, TensorFlow est la bibliothèque d'apprentissage profond la plus présente sur GitHub.
• Les professionnels utilisent TensorFlow car il se déploie facilement à grande échelle, dans le cloud, dans le navigateur ou sur les appareils mobiles fonctionnant sous iOS et Android. Android.

TensorFlow fonctionne par session. Chaque session est définie par un graphe contenant différents calculs. Un exemple simple consiste à multiplier un nombre. Avec TensorFlow, trois étapes sont nécessaires :

1. Définir la variable

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

2. Définir le calcul

multiply = tf.multiply(X_1, X_2, name = "multiply")

3. Exécutez l'opération

with tf.Session() as session:
    result = session.run(multiply, feed_dict={X_1: [1, 2, 3], X_2: [4, 5, 6]})
    print(result)

Une pratique courante avec TensorFlow consiste à créer un pipeline pour charger les données. En suivant ces cinq étapes, vous pourrez charger des données dans TensorFlow :

1. Créer les données

import numpy as np
x_input = np.random.sample((1,2))
print(x_input)

2. Créer l'espace réservé

x = tf.placeholder(tf.float32, shape=[1,2], name = 'X')

3. Définir la méthode de jeu de données

dataset = tf.data.Dataset.from_tensor_slices(x)

4. Créer le pipeline

iterator = dataset.make_initializable_iterator()
get_next = iterator.get_next()

5. Exécuter le programme

with tf.Session() as sess:
    sess.run(iterator.initializer, feed_dict={x: x_input})
    print(sess.run(get_next))

FAQ