Les objets Variable dans TensorFlow représentent des tenseurs modifiables qui persistent entre les exécutions d'opérations. Contrairement aux constantes, leur valeur peut être actualisée durant l'entraînement d'un modèle.

Modification des valeurs avec assign()

La méthode assign() permet de remplacer la valeur d'une variable. L'exemple suivant illustre une mise à jour multiplicative répétée :

import tensorflow as tf

# Déclaration d'une variable initialisée à 3
compteur = tf.Variable(3, dtype=tf.int32)

# Opération de mise à jour : multiplication par 3
tripler = compteur.assign(compteur * 3)

# Préparation de l'initialisation
demarrage = tf.global_variables_initializer()

with tf.Session() as session:
    session.run(demarrage)
    
    # Première exécution : 3 × 3 = 9
    print(session.run(tripler))  # 9
    
    # Deuxième exécution : 9 × 3 = 27
    print(session.run(tripler))  # 27
    
    # Troisième exécution : 27 × 3 = 81
    print(session.run(tripler))  # 81

Opérations d'incrémentation et décrémentation

TensorFlow fournit des méthodes spécialisées pour les ajustements arithmétiques : assign_add() pour l'addition et assign_sub() pour la soustraction. Ces opérations sont particulièrement utiles pour les compteurs et les accumulateurs de gradients.

import tensorflow as tf

# Variable compteur démarrant à zéro
score = tf.Variable(0, name="score_total")

# Initialisation globale
preparation = tf.global_variables_initializer()

# Création de deux contextes d'exécution indépendants
with tf.Session() as contexte_a, tf.Session() as contexte_b:
    
    # Contexte A : accumulation par pas de 7
    contexte_a.run(preparation)
    print(contexte_a.run(score.assign_add(7)))   # 7
    print(contexte_a.run(score.assign_add(7)))   # 14
    
    # Contexte B : accumulation par pas de 3 (état indépendant)
    contexte_b.run(preparation)
    print(contexte_b.run(score.assign_add(3)))   # 3
    print(contexte_b.run(score.assign_add(3)))   # 6
    
    # Retour au contexte A : poursuite de son état (14)
    print(contexte_a.run(score.assign_add(7)))   # 21
    
    # Décrémentation dans le contexte B
    print(contexte_b.run(score.assign_sub(5)))   # 1
    
    # Réinitialisation du contexte A
    contexte_a.run(preparation)
    print(contexte_a.run(score))                   # 0
    
    # Le contexte B conserve sa valeur
    print(contexte_b.run(score))                   # 1

Isolation des états entre sessions

Chaque instance de Session maintient sa propre copie des valeurs des variables. La réinitialisation via global_variables_initializer() n'affecte que la session où elle est exécutée, permettant des expérimentations parallèles avec des paramètres identiques.

import tensorflow as tf

# Définition d'une variable avec valeur initiale 100
seuil = tf.Variable(100.0, dtype=tf.float32)

# Opérations combinées
ajustement = seuil.assign_add(-15.0)  # Soustraction de 15
restauration = tf.global_variables_initializer()

with tf.Session() as s1, tf.Session() as s2:
    # Session 1 : diminution progressive
    s1.run(restauration)
    for _ in range(3):
        print(f"S1 après ajustement : {s1.run(ajustement):.1f}")
        # 85.0, 70.0, 55.0
    
    # Session 2 : valeur intacte à 100
    s2.run(restauration)
    print(f"S2 valeur initiale : {s2.run(seuil):.1f}")  # 100.0
    
    # Réinitialisation de S1 sans affecter S2
    s1.run(restauration)
    print(f"S1 réinitialisé : {s1.run(seuil):.1f}")     # 100.0
    print(f"S2 inchangé : {s2.run(seuil):.1f}")         # 100.0

Cette isolation garantit que les expérimentations multiples sur le même graphe computationnel ne s'interfèrent pas, facilitant le débogage et la comparaison d'hyperparamètres.