Pour démarrer rapidement avec la programmation TensorFlow, considérons cet exemple de code simple :
import tensorflow as tf
# Définition de variables symboliques, aussi appelées espaces réservés
input_1 = tf.placeholder(tf.float32)
input_2 = tf.placeholder(tf.float32)
# Construction d'un opération de multiplication
operation = tf.multiply(input_1, input_2)
# Création d'une session et exécution
session = tf.Session()
result = session.run(operation, feed_dict={input_1: 4.0, input_2: 5.0})
print(result)
session.close()
La fonction tf.multiply constitue une opération arithmétique de base. Voyons ensuite les différentes catégories d'opérations disponibles.
Opérations arithmétiques
TensorFlow convertit les définitions de graphes en opérations exécutables de manière distribuée, exploitant automatiquement les ressources de calcul (CPU ou GPU) disponibles. Les calculs parallèles accélèrent les algorithmes complexes. Voici les opérations mathématiques fondamentales :
| Fonction | Description |
|---|---|
tf.add(x, y) |
Addition |
tf.subtract(x, y) |
Soustraction |
tf.multiply(x, y) |
Multiplication |
tf.divide(x, y) |
Division |
tf.floormod(x, y) |
Modulo entier |
tf.abs(x) |
Valeur absolue |
tf.negative(x) |
Opposé (y = -x) |
tf.sign(x) |
Renvoie le signe |
tf.square(x) |
Carré (y = x²) |
tf.sqrt(x) |
Racine carrée (y = √x) |
tf.pow(x, y) |
Puissance (x^y) |
tf.exp(x) |
Exponentielle (e^x) |
tf.log(x) |
Logarithme naturel (ln) |
tf.maximum(x, y) |
Maximum entre x et y |
tf.minimum(x, y) |
Minimum entre x et y |
Manipulation des tenseurs
Conversion de types
| Fonction | Description |
|---|---|
tf.cast(x, dtype) |
Convertit le type de données |
tf.string_to_number(str_tensor) |
Convertit une chaîne en nombre |
tf.to_float(x) |
Convertit en float32 |
tf.to_int32(x) |
Convertit en int32 |
Opérations sur les formes
| Fnoction | Description |
|---|---|
tf.shape(input) |
Renvoie la forme du tenseur |
tf.size(input) |
Nombre total d'éléments |
tf.rank(input) |
Nombre de dimensions |
tf.reshape(tensor, shape) |
Redimensionne le tenseur |
tf.expand_dims(input, axis) |
Ajoute une dimension de taille 1 |
Découpage et assemblage
| Fonction | Description |
|---|---|
tf.slice(input, begin, size) |
Extrait une tranche du tenseur |
tf.split(value, num_split, axis) |
Divise le tenseur le long d'un axe |
tf.concat(values, axis) |
Concatène les tenseurs |
tf.stack(values, axis) |
Empile les tenseurs le long d'un nouvel axe |
tf.reverse(tensor, axis) |
Inverse le tenseur le long d'axes spécifiés |
tf.transpose(a, perm) |
Permuts les dimensions |
Opérations marticielles
| Fonction | Description |
|---|---|
tf.diag(diagonal) |
Crée une matrice diagonale |
tf.matmul(a, b) |
Produit matriciel |
tf.matrix_determinant(input) |
Calcul du déterminant |
tf.matrix_inverse(input) |
Inversion de matrice |
tf.cholesky(input) |
Décomposition de Cholesky |
Réduction et segmentation
Les opérations de réduction permettent de calculer des statistiuqes sur des tenseurs :
donnees = tf.constant([[2, 5], [3, 7]])
somme_totale = tf.reduce_sum(donnees) # 17
somme_colonnes = tf.reduce_sum(donnees, axis=0) # [5, 12]
moyenne = tf.reduce_mean(donnees) # 4.25
Les fonctions de segmentation appliquent des opérations par groupes définis par des identifiants :
valeurs = tf.constant([[10, 20], [30, 40], [50, 60]])
segments = tf.constant([0, 0, 1])
resultat = tf.unsorted_segment_sum(valeurs, segments, num_segments=2)
# Résultat : [[40, 60], [50, 60]]
Composants pour réseaux de neurones
Fonctions d'activation
| Fonction | Description |
|---|---|
tf.nn.relu(features) |
Unité linéaire rectifiée (max(0, x)) |
tf.nn.sigmoid(x) |
Logistic sigmoid (1 / (1 + exp(-x))) |
tf.nn.tanh(x) |
Tangente hyperbolique |
tf.nn.dropout(x, rate) |
Applique un dropout pendant l'entraînement |
Convolutions et pooling
| Fonction | Description |
|---|---|
tf.nn.conv2d(input, filters, strides, padding) |
Convolution 2D |
tf.nn.max_pool2d(input, ksize, strides, padding) |
Pooling maximum 2D |
tf.nn.avg_pool2d(input, ksize, strides, padding) |
Pooling moyen 2D |
Réseaux de neurones récurrents
TensorFlow offre plusieurs API pour les RNN, avec une gestion dynamique des séquences de longueur variable :
# Exemple avec une cellule GRU
cellule_gru = tf.nn.GRUCell(unitees=128)
sortie, etat_final = tf.nn.dynamic_rnn(cellule_gru, sequences, dtype=tf.float32)
Sauvegarde et restauration des variables
La classe tf.train.Saver permet de sauvegarder et restaurer l'état du modèle :
saver = tf.train.Saver()
saver.save(session, "chemin/vers/modele", global_step=epoch)
# Restauration
saver.restore(session, "chemin/vers/modele-1000")
Ces mécanismes assurent la persistance des paramètres du modèle entre les sessions d'entraînement.