Projet de recherche sur l'approximation d'opérateurs pour l'équation de Ginzburg-Landau complexe 1D avec un PI-DeepONet (Physics-Informed Deep Operator Network).
L'objectif du dépôt est d'apprendre l'opérateur qui associe :
- un jeu de paramètres physiques,
- une condition initiale paramétrée,
- une coordonnée spatio-temporelle
(x, t),
à la solution complexe u(x, t) de la PDE, en utilisant principalement la physique comme signal d'entraînement.
Le dépôt contient aussi un solveur numérique CGL utilisé pour l'audit et le diagnostic, mais pas comme supervision directe dans la boucle d'entraînement principale.
Le code entraîne un modèle sur une forme 1D de l'équation de Ginzburg-Landau complexe :
où :
alphacontrôle la dispersion/diffusion complexe,betacontrôle la non-linéarité complexe,muest le terme linéaire de gain/perte,Vest le terme d'advection,u(x,t)est un champ complexe.
Dans la configuration actuelle :
- le domaine spatial est
x in [-40, 40], - le temps final par défaut est
t_max = 5, - les conditions initiales utilisées sont gaussiennes,
x0est actuellement fixé à0dans la config fournie,kvarie dans[-2, 2].
Le but n'est pas seulement d'approximer une trajectoire unique, mais d'apprendre un opérateur paramétrique sur une famille d'équations et de conditions initiales.
Cette approche est intéressante quand :
- on veut balayer un espace de paramètres rapidement après entraînement,
- le solveur numérique devient trop coûteux,
- on vise à terme des PDE plus complexes pour lesquelles il n'existe pas de vérité terrain dense facilement disponible.
Le choix assumé de ce dépôt est donc :
- entraînement principalement par résidu PDE et contraintes physiques,
- solveur numérique réservé à l'audit, au débogage et à l'évaluation.
La CGL générale n'est pas, en général, un système conservatif au sens NLS. On ne dispose donc pas d'une énergie universellement conservée simple.
En revanche, pour l'équation implémentée ici, on peut exploiter une balance intégrale de la norme L2 :
quand les termes de bord ne contribuent pas.
Cette identité est utile car elle fournit une contrainte physique globale sans recourir à une solution de référence. Le code l'utilise maintenant comme perte auxiliaire de stabilisation.
Le modèle apprend un opérateur
(paramètres physiques, paramètres de CI, x, t) -> u(x, t)
avec deux sous-réseaux :
- un
branch netpour encoder les paramètres, - un
trunk netpour encoder les coordonnées.
Le produit des représentations latentes branch et trunk reconstruit la sortie complexe.
Dans ce dépôt :
- la sortie est décomposée en partie réelle et imaginaire,
- la condition initiale gaussienne est imposée de manière analytique,
- le réseau apprend surtout la correction dynamique au-delà de
t=0.
Le modèle principal est défini dans src/models/cgl_deeponet.py.
Le branch net reçoit un vecteur de 9 paramètres :
alphabetamuVAw0x0ktype
Le trunk net reçoit les coordonnées (x, t).
Le modèle normalise :
- linéairement les paramètres bornés,
- logarithmiquement
w0, - temporellement
tsur[0, t_max].
Le trunk utilise un encodage de Fourier multi-échelle pour améliorer la représentation des structures oscillantes et multirésolution.
Le modèle ne travaille pas directement sur x brut. Il construit une coordonnée comobile :
xi = (x - x0) / W(t)
avec une largeur dynamique W(t) dépendant de w0 et t.
L'idée est de suivre l'étalement de l'enveloppe pour faciliter l'approximation.
La condition initiale est imposée analytiquement via un ansatz :
- le réseau reproduit exactement la gaussienne initiale à
t=0, - la correction apprise est activée progressivement via un facteur de transition temporelle.
Cela évite d'avoir à entraîner explicitement une loss de condition initiale.
La logique principale se trouve dans src/training/trainer_CGL.py.
L'entraînement est principalement physics-informed :
- on ne supervise pas le modèle avec des profils solveur dans la loss principale,
- on optimise un mélange de contraintes locales et globales issues de la physique.
La loss d'entraînement combine maintenant :
- un résidu PDE fort absolu,
- un résidu PDE relatif,
- une perte faible intégrale sur quelques fonctions tests,
- une contrainte de bord de type Neumann sur
x_minetx_max, - une perte de balance de masse
L2, - une perte de continuité causale entre deux fenêtres temporelles.
Cette combinaison vise à éviter le cas classique :
losslocale très faible,- mais erreur solution globale encore élevée à l'audit.
L'entraînement est organisé par fenêtres temporelles successives :
- on avance de
t_prevverst_curr, - on valide localement le nouveau cap,
- on surveille l'oubli historique,
- on adapte
dtsi nécessaire.
Le sampler PDE causal mélange :
- une partie de points dans le passé,
- une partie de points près du front actif.
Avant chaque nouvelle fenêtre, le modèle courant est figé comme teacher.
Pendant l'optimisation de la fenêtre suivante, le modèle entraîné est pénalisé s'il s'écarte trop de ce teacher sur la tranche t = t_prev.
Ce n'est pas une supervision par vérité terrain. C'est une contrainte de cohérence interne entre deux étapes de propagation.
Le dépôt utilise un mécanisme de RAR (Residual-based Adaptive Refinement) :
- génération d'un grand ensemble de points candidats,
- calcul du résidu PDE,
- sélection des points les plus difficiles.
La version actuelle renforce aussi les régions :
- à forte énergie locale,
- à fort gradient d'amplitude.
Si Adam s'approche de la cible sans l'atteindre complètement, un passage L-BFGS est lancé comme étape de finition locale.
L'audit est géré dans run_audit dans src/training/trainer_CGL.py.
Le solveur numérique CGL est implémenté dans src/utils/solver_cgl.py.
Son rôle est :
- évaluer la progression réelle,
- détecter les plateaux,
- estimer l'erreur relative
L2, - vérifier l'oubli historique.
Son rôle n'est pas :
- fournir une loss supervisée dans la boucle d'entraînement standard.
L'audit échantillonne désormais les paramètres sur la même famille de problèmes, y compris k.
Arborescence logique :
.
├── configs/
│ └── cgl_config.yaml
├── launch/
│ ├── jz_submit_CGL.slurm
│ └── jz_submit_CGL_reprise.slurm
├── scripts/
│ ├── train_cgl.py
│ ├── train_cgl_resume.py
│ ├── test_debug.py
│ ├── test_visu.py
│ └── test_animation.py
├── src/
│ ├── data/
│ │ └── generators.py
│ ├── models/
│ │ └── cgl_deeponet.py
│ ├── physics/
│ │ └── pde_cgl.py
│ ├── plot/
│ │ ├── plot_animation.py
│ │ └── plot_snapshot.py
│ ├── training/
│ │ └── trainer_CGL.py
│ └── utils/
│ └── solver_cgl.py
├── analyse_cgl.py
└── requirements.txt
-
configs/cgl_config.yaml configuration physique, modèle et entraînement.
-
src/models/cgl_deeponet.py architecture du PI-DeepONet.
-
src/physics/pde_cgl.py calcul du résidu PDE et de ses composantes.
-
src/data/generators.py génération des batches PDE, interface causale, balance de masse, RAR.
-
src/training/trainer_CGL.py boucle d'entraînement, navigation temporelle, audit, checkpointing.
-
src/utils/solver_cgl.py solveur numérique CGL pour audit.
-
scripts/train_cgl.py point d'entrée principal pour lancer un run.
Le fichier principal est configs/cgl_config.yaml.
Il contient :
- la définition du problème physique,
- les bornes de paramètres,
- les hyperparamètres du modèle,
- les tailles de batch,
- les poids des pertes physiques auxiliaires,
- les zones temporelles de la navigation.
Les nouveaux poids utiles sont dans :
training:
physics_losses:
pde_relative_weight: 0.5
weak_weight: 0.05
mass_weight: 0.05
continuity_weight: 0.1
mass_n_cases: 16
mass_n_x: 128
continuity_batch_size: 2048Interprétation pratique :
pde_relative_weightaugmente l'importance du résidu relatif,weak_weightrenforce la contrainte variationnelle,mass_weightimpose davantage la balance globale,continuity_weightstabilise le passage d'une fenêtre temporelle à la suivante.
La stratégie effective est la suivante :
- initialiser le modèle et l'optimiseur,
- démarrer à
t_prev = 0, - proposer un cap
t_curr = t_prev + dt, - faire un audit local rapide,
- si nécessaire, lancer une optimisation adaptative sur la fenêtre,
- valider aussi l'historique,
- éventuellement lancer une
Rescue Loopglobale, - sauvegarder un checkpoint,
- avancer au cap suivant,
- finir par un polissage global.
Cette boucle joue le rôle de navigator.
Créer un environnement Python puis installer les dépendances :
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txtDépendances listées dans requirements.txt :
matplotlibnumpyscipytorchtqdmPyYAML
python scripts/train_cgl.py --config configs/cgl_config.yamlLe script :
- crée un dossier
results/CGL_Navigator_Run_<timestamp>/, - crée un sous-dossier
checkpoints/, - entraîne le modèle,
- sauvegarde les checkpoints et le modèle final.
python scripts/train_cgl.py --resume latestpython scripts/train_cgl.py --resume results/CGL_Navigator_Run_YYYYMMDD-HHMMSSou :
python scripts/train_cgl_resume.py --resume latestLe dépôt contient des scripts SLURM dans launch/.
Fichiers disponibles :
Le flux typique est :
- adapter les ressources SLURM,
- charger l'environnement Python/CUDA adapté,
- soumettre avec
sbatch.
Les checkpoints sont stockés dans le dossier du run, typiquement :
results/CGL_Navigator_Run_<timestamp>/checkpoints/
On y trouve :
- des checkpoints par cap temporel
ckpt_tXXXX.pth, model_latest.pthpour la reprise automatique,- éventuellement des diagnostics CSV selon les runs.
Le modèle final est aussi sauvegardé à la racine du run.
Si la loss baisse mais que l'audit stagne :
- regarder séparément
PDE(abs/rel/weak), - surveiller
Mass, - surveiller
Cont, - augmenter
pde_relative_weightsi le résidu absolu devient trop trompeur, - réduire
continuity_weightsi l'apprentissage devient trop rigide, - réduire
mass_weightsi la contrainte intégrale domine trop tôt.
Réglages raisonnables de départ :
pde_relative_weight: 0.5weak_weight: 0.05mass_weight: 0.02à0.05continuity_weight: 0.03à0.1
- l'audit repose encore sur un solveur numérique, donc il reste coûteux,
- le problème actuellement configuré est centré sur des CI gaussiennes,
- la performance peut rester sensible au sampling en temps et en espace,
- le coût CPU de l'audit est nettement plus élevé que celui des tests purement syntaxiques.
Ce dépôt implémente un PI-DeepONet pour la CGL 1D avec :
- condition initiale imposée analytiquement,
- entraînement principalement guidé par la physique,
- navigation temporelle causale,
- audit solveur séparé,
- contraintes physiques auxiliaires pour limiter les faux plateaux de résidu.
Le dépôt est conçu comme une base de travail vers des PDE plus complexes où la vérité terrain ne sera plus accessible pendant l'entraînement.