Liquid Neural Networks (LNNs)

Les réseaux neuronaux liquides (LNN) sont une famille de réseaux neuronaux récurrents (RNN) en temps continu, dans lesquels l'état de chaque neurone suit une équation différentielle dont la constante de temps dépend de l'entrée actuelle ; la vitesse de réaction d'un neurone change donc d'un instant à l'autre. Ramin Hasani, Mathias Lechner et leurs collègues du MIT, de l'IST Austria et de la TU Wien ont présenté le modèle de base, le réseau à constante de temps liquide (LTC), à AAAI 2021, en s'inspirant de modèles du système nerveux du nématode C. elegans, qui compte 302 neurones. Les LNN sont de petite taille, souvent composés de quelques dizaines de neurones, et sont principalement utilisés pour l'analyse de séries temporelles et le pilotage de véhicules et de drones, où leur compacité facilite l'inspection du comportement appris. Leur entraînement fixe leurs poids, comme dans n'importe quel réseau ; la partie « liquide » correspond à leur dynamique, que l'entrée remodèle à chaque étape.

Fonctionnement des réseaux à constante de temps liquide#

Un RNN en temps continu décrit son état caché x(t) à l'aide d'une équation différentielle ordinaire, comme le font les ODE neuronales, plutôt qu'avec une mise à jour discrète. Un réseau LTC utilise dx/dt = −[1/τ + f(x, I, θ)] ⊙ x + f(x, I, θ) ⊙ A, où I(t) est l'entrée, τ est une constante de temps de base pour chaque neurone, A est un vecteur de biais entraînable, et f est un petit réseau neuronal dont la sortie bornée est de type sigmoïde. Comme f intervient dans le taux de décroissance, la constante de temps effective de chaque neurone est τ_sys = τ / (1 + τ f) ; elle diminue lorsque f est grand, ce qui accélère la réaction du neurone, et se rapproche de τ lorsque f est proche de zéro. L'article démontre que τ_sys et l'état restent dans des limites fixes, ce qui assure la stabilité du réseau même lorsque les entrées sont très grandes.

L’entraînement déroule un solveur numérique d’ODE et rétropropage le gradient à travers ce solveur. Le solveur fusionné des auteurs effectue un pas semi-implicite, x(t + Δt) = [x(t) + Δt f A] / [1 + Δt (1/τ + f)] ; l’extrait de code PyTorch ci-dessous met en œuvre ce pas pour quatre neurones et fournit au solveur trois entrées différentes :

import torch
from torch import nn

torch.manual_seed(0)
n_inputs, n_neurons, dt = 2, 4, 0.1
f = nn.Linear(n_inputs + n_neurons, n_neurons)  # gate network f(x, I); its weights stay fixed below
tau = torch.full((n_neurons,), 2.0)  # base time constant of each neuron
A = torch.randn(n_neurons)  # level each neuron is pulled toward when its gate opens


def ltc_step(x, I):
    """One fused-solver step of dx/dt = -(1/tau + f) * x + f * A, plus the effective time constant."""
    gate = torch.sigmoid(f(torch.cat([I, x])))
    x_next = (x + dt * gate * A) / (1 + dt * (1 / tau + gate))
    return x_next, tau / (1 + tau * gate)


x = torch.zeros(n_neurons)
for I in [torch.tensor([0.0, 0.0]), torch.tensor([5.0, -5.0]), torch.tensor([-5.0, 5.0])]:
    x, tau_sys = ltc_step(x, I)
    print(f"Input {I.tolist()}: time constants {[round(t, 2) for t in tau_sys.tolist()]}")

Le programme affiche les constantes de temps effectives [1.02, 0.99, 0.92, 1.1] pour une entrée nulle, [1.35, 1.5, 1.06, 1.26] pour l'entrée (5, −5) et [0.8, 0.74, 0.82, 0.97] pour l'entrée (−5, 5). Avec les mêmes poids, la constante de temps du deuxième neurone varie de 0,74 à 1,5, soit un facteur deux, en fonction de la seule entrée du réseau. Comme l'état évolue en temps continu, Δt peut aussi correspondre à l'intervalle réel entre les échantillons ; les LNN peuvent ainsi lire des données échantillonnées de façon irrégulière, comme des dossiers médicaux ou des capteurs événementiels, sans les rééchantillonner à une fréquence fixe.

Politiques de circuits neuronaux et réseaux CfC#

Deux travaux connexes du même groupe ont appliqué les neurones LTC au contrôle et supprimé le coût du solveur d'ODE :

• Politiques de circuits neuronaux (NCP) : dans un article paru dans Nature Machine Intelligence en 2020, Lechner, Hasani et leurs collègues ont relié des neurones LTC en un circuit clairsemé à plusieurs couches, inspiré de C. elegans et composé de neurones sensoriels, intermédiaires, de commande et moteurs. Placée derrière un extracteur de caractéristiques convolutif, une politique composée de 19 neurones de commande et de 253 synapses a appris à piloter une voiture à partir d'images de caméra pour qu'elle reste dans sa voie ; selon l'article, elle généralisait mieux et résistait davantage au bruit que des contrôleurs boîte noire de plusieurs ordres de grandeur plus grands.
• Réseaux continus en forme fermée (CfC) : Hasani et ses collègues ont montré en 2022 qu'une approximation en forme fermée de la solution LTC élimine le solveur numérique, accélérant l'entraînement et l'inférence d'un à cinq ordres de grandeur par rapport aux équivalents fondés sur des ODE, tout en conservant le comportement en temps continu.

La bibliothèque ncps des auteurs implémente les cellules LTC et CfC ainsi que les connexions NCP pour PyTorch et Keras.

Applications#

• Navigation de drones : dans une étude publiée dans Science Robotics en 2023, des drones contrôlés par des réseaux liquides ont appris à rejoindre une cible à partir de démonstrations de pilotage humain enregistrées dans une forêt en été, puis ont accompli la tâche dans une forêt en hiver, en milieu urbain et avec l'ajout de bruit, de rotation et d'occultation, surpassant de nombreuses solutions de pointe.
• Séries temporelles médicales et de capteurs : les modèles en temps continu conviennent aux flux irréguliers, comme les mesures en soins intensifs, où les relevés arrivent chaque fois qu'un examen est effectué.
• Pipelines de la perception au contrôle : un contrôleur liquide a besoin de caractéristiques compactes pour chaque image, que YOLO26 peut fournir : son mode predict, avec stream=True, renvoie un résultat par image vidéo sous forme de générateur ; les coordonnées des boîtes ou les points clés de pose parviennent donc au contrôleur au fur et à mesure du traitement des images.

LNN et modèles connexes#

• LSTM et GRU : des cellules à temps discret qui se mettent à jour à chaque étape d'entrée, sans tenir compte du temps écoulé entre les étapes. Les neurones LTC évoluent en continu, et les contrôleurs qui en sont composés utilisent généralement beaucoup moins de neurones.
• ODE neuronales : les réseaux LTC sont des ODE neuronales de forme bornée spécifique qui garantit la stabilité de leur dynamique.
• Réseaux neuronaux à impulsions : eux aussi inspirés du cerveau, ils utilisent des neurones qui communiquent par impulsions discrètes. Les neurones LTC ont des états continus, inspirés des neurones sans impulsions de C. elegans.
• Modèles d'espace d'états : eux aussi fondés sur des récurrences en temps continu, discrétisées pour le calcul. Mamba calcule son pas à partir de chaque entrée, ce qui donne à chaque canal une constante de temps dépendante de l'entrée, et le groupe de Hasani a combiné le modèle d'espace d'états S4 avec la dynamique LTC dans Liquid-S4, présenté à ICLR 2023.
• Modèles de Liquid AI : Hasani, Lechner, Alexander Amini et Daniela Rus ont fondé Liquid AI, une spin-off du MIT CSAIL, en 2023. Ses modèles de langage LFM2, publiés en juillet 2025, associent de courtes convolutions à portes à un petit nombre de couches d'attention à requêtes groupées. Cette architecture est distincte des réseaux LTC, malgré leur nom « liquide » commun.