Reproduire les Benchmarks DInf-Grid en 10 Étapes

Quand les graphiques de convergence et les courbes de Pareto ne s’accordent pas entre les articles, c’est presque toujours un problème de protocole, pas une découverte de modèle. Le protocole DInf-Grid s’attaque à ce problème en standardisant les échelles de raffinement, les normes d’erreur, et le rapport de coût à travers les solveurs classiques et appris pour les ODEs et PDEs sur des grilles structurées. Il se concentre sur l’ordre de convergence empirique (EOC), les compromis précision-coût, et la stabilité—tout cela de manière reproductible, avec plusieurs graines et configurations matérielles. Cet article est un guide pratique pour le professionnel: 10 étapes concrètes, choix d’outils, écueils à éviter, et ce qu’il faut emballer pour que vos graphiques de convergence et de Pareto soient fiables et comparables.

Vous apprendrez à: (1) choisir des problèmes représentatifs et des vérités de terrain; (2) aligner les solveurs de référence et les tolérances à la physique; (3) construire des échelles de raffinement spatiales, temporelles et spectrales; (4) implémenter des bases classiques pour des vérifications de solidité; (5) configurer des méthodes apprises avec des régimes d’entraînement clairs; (6) concevoir des balayages contrôlés et des ablations; (7) calculer les erreurs et l’EOC de manière cohérente; (8) profiler le coût et assembler les frontières de Pareto; (9) tester la stabilité et la généralisation; et (10) emballer les artefacts pour une vérification externe. Les outils couvrent DifferentialEquations.jl, SUNDIALS, PETSc TS, FEniCS/deal.II, Clawpack, Dedalus, torchdiffeq/Diffrax, DeepXDE/NeuralPDE.jl, FNO/DeepONet/PINO, torchsde, PDEBench, et JAX-CFD.

Détails de l’Architecture/Implémentation

Étape 1 — Sélectionner des problèmes représentatifs et définir la vérité de terrain

Associez votre application à des familles canoniques: ODEs non-raides ou raides, PDEs elliptiques stationnaires, équations paraboliques diffuses, et transport hyperbolique avec chocs. Fixez les domaines, coefficients, et conditions initiales/frontières. Incluez des cas lisses et des défis connus (e.g., couches raides, discontinuités) et rédigez des spécifications précises dans les fichiers de configuration pour éliminer toute ambiguïté en aval. Utilisez PDEBench et JAX-CFD lorsque pertinent pour standardiser les flux périodiques et les ensembles de données.

Les exemples selon le protocole incluent: oscillateur harmonique et Lorenz-63/96 (non-raide), Van der Pol (μ ≫ 1), Robertson, HIRES (raide), Poisson/Darcy (elliptique), chaleur/Allen–Cahn/Cahn–Hilliard (parabolique), et advection/Burgers/eaux peu profondes/Euler (hyperbolique) avec frontières Dirichlet, Neumann, et périodiques représentées.

Étape 2 — Établir des solveurs de référence et des tolérances

Choisissez des méthodes de confiance alignées avec la physique: multistep implicites ou collocation pour les ODEs raides (e.g., BDF/Radau/SDIRK via SUNDIALS, DifferentialEquations.jl), FEM accéléré par multigrille pour les solutions elliptiques (FEniCS ou deal.II avec HYPRE), schémas stables en volumes finis pour les PDEs hyperboliques (WENO + SSP Runge–Kutta dans Clawpack), et piles spectrales pour les flux périodiques (Dedalus). Exécutez les références à des tolérances serrées ou à des résolutions très fines et archivez les paramètres du solveur: seuils de résolution non linéaire/linéaire, préconditionneurs, et résolutions maillage/temps.

Étape 3 — Construire des échelles de raffinement

Pour les grilles structurées, divisez h par deux à chaque niveau spatial; pour les spectrals, doublez les modes avec un désaliasage cohérent; pour le temps, construisez des échelles dt fixes pour les schémas uniformes et des échelles de tolérance pour les solveurs adaptatifs. Pour les intégrateurs PDE explicites, adaptez dt avec h pour maintenir un nombre de Courant stable; fixez un temps final commun pour les ODEs et les PDEs dépendantes du temps pour assurer des comparaisons équitables. Pour les solveurs ODE adaptatifs, utilisez des échelles de tolérance (e.g., 1e−2…1e−8), et enregistrez les tailles et comptes de pas réalisés.

Étape 4 — Implémenter des bases classiques

Avant d’introduire l’apprentissage, validez l’environnement: Runge–Kutta explicite et paires adaptatives pour les ODEs non-raides; BDF, Radau, et IMEX pour les ODEs raides; FEM/FV/FD ou spectrales pour les PDEs; WENO avec des intégrateurs de temps SSP pour les problèmes hyperboliques. Vérifiez que les pentes de convergence dans les régimes lisses correspondent aux ordres formels et se dégradent près des chocs comme le prédit la théorie.

Étape 5 — Configurer des méthodes apprises avec des régimes d’entraînement clairs

• ODEs neuronales: définissez les architectures de champ vectoriel, les trajectoires d’entraînement, et l’arrière-plan d’intégration (adaptatif/fixe), en utilisant torchdiffeq ou Diffrax.
• PINNs: spécifiez l’échantillonnage par collocation, l’application des frontières, et la quadrature via DeepXDE ou NeuralPDE.jl.
• Opérateurs neuronaux: définissez les résolutions d’entrée/sortie, le remplissage spectral, les règles anti-aliasing, et la régularisation physique pour FNO/DeepONet/PINO.
• Pas de temps appris: concevez des corrections/fluxes entraînables cohérents avec le schéma hôte.
• EDS: choisissez des objectifs forts/faibles et des discrétisations avec torchsde. Documentez la taille des modèles, la régularisation, les optimiseurs, et les planificateurs selon le même style de configuration utilisé pour les bases.

Étape 6 — Effectuer des balayages contrôlés et des ablations

Stratifiez par discrétisation (uniforme contre adaptative, explicite contre implicite), régime de données (supervisé contre informé par la physique), et facteurs modèle/entraînement (profondeur/largeur, pondération des résidus, optimiseur). Traitez le budget d’entraînement comme une variable de première classe—enregistrez les heures GPU et le temps réel. Appliquez des critères d’arrêt précoce cohérents à travers les exécutions; envisagez le programme et la décomposition de domaine pour les dimensions supérieures dans les configurations informées par la physique.

Étape 7 — Mesurer les erreurs avec des normes cohérentes et calculer la convergence

Calculez les erreurs sur la même grille que les références. Pour les PDEs, rapportez les L2 et L∞ discrètes (et les versions relatives si appropriées); pour les problèmes paraboliques, incluez les erreurs de temps terminal et moyennées dans le temps; pour les hyperboliques, complétez l’EOC en régime lisse avec l’erreur de temps de choc et la variation totale. Pour les ODEs, incluez l’erreur de l’état terminal et éventuellement l’erreur MSE de la trajectoire sur une grille de contrôle. Estimez l’EOC via p̂ = log(E(h)/E(h/2))/log(2), avec des intervalles de confiance bootstrap sur ≥5 graines pour les solveurs appris.

Étape 8 — Profiler le coût et construire les frontières de Pareto

Décomposez le coût de formation contre l’inférence. Utilisez des profileurs FLOPs/mémoire cohérents (ptflops, fvcore) et une synchronisation avec échauffements. Pour les codes classiques adaptatifs, enregistrez les pas acceptés et les itérations non linéaires/linéaires; pour les modèles appris, enregistrez les FLOPs par passage en avant et la mémoire de pointe. Tracez l’erreur contre le coût avec des vues séparées pour l’inférence uniquement et le total (formation + inférence). Ajoutez des tracés de précision ajustée pour les intégrateurs adaptatifs pour isoler les vertus de l’adaptivité.

Étape 9 — Tester la stabilité et la généralisation

Déployez au-delà des fenêtres de formation pour sonder le comportement à long terme. Suivez les invariants/dérive d’énergie pour les dynamiques hamiltoniennes et les spectres d’énergie/enstrophie pour les flux incompressibles. Pour les apprenants d’opérateurs, évaluez à des résolutions plus élevées que la formation pour cartographier la généralisation de résolution jusqu’à ce que l’erreur se stabilise. Variez les frontières (périodique ↔ Dirichlet) pour évaluer la sensibilité à l’incrustation BC. Confirmez que les corrections des pas de temps appris diminuent sous le raffinement de sorte que l’ordre formel du schéma hôte est récupéré.

Étape 10 — Emballer les artefacts reproductibles et publier les diagnostics

Consolidez les fichiers de configuration, les journaux, les points de contrôle entraînés, les sorties brutes, et les métadonnées par expérience (matériel, versions logicielles, graines, paramètres de solveur exacts). Organisez des graphiques de convergence avec des pentes et des bandes de confiance, des graphiques Pareto précision–coût, et des tableaux de bord de stabilité. Fournissez un court README par benchmark détaillant les définitions de problème et les instructions de réexécution. Cela permet une vérification externe et des méta-analyses en aval.

Tableaux de Comparaison

Piles d’outils par classe d’équation

Classe d’équation	Pile classique (de base)	Pile apprise (exemples)
ODE non raide	RK explicite (fixe/adaptatif), DP/RK45 via DifferentialEquations.jl/SciPy	ODEs neuronales avec torchdiffeq/Diffrax
ODE raide	BDF/Radau/SDIRK/IMEX via SUNDIALS, OrdinaryDiffEq.jl	ODEs neuronales avec intégrateurs implicites
PDE elliptique	FEM (FEniCS/deal.II) avec multigrille HYPRE	PINNs (DeepXDE/NeuralPDE.jl), DeepONet/FNO/PINO
PDE parabolique	PETSc TS (Euler arrière, CN, BDF, IMEX), Dedalus pour spectral	PINNs et opérateurs neuronaux
PDE hyperbolique	Clawpack WENO + SSP-RK	Variantes de PINNs, FNO/PINO (attention aux chocs)
Flux périodique	Dedalus spectral; références JAX-CFD	FNO/DeepONet/PINO
EDS	Bases Euler–Maruyama/Milstein (dépend du schéma)	torchsde avec objectifs forts/faibles

Forces et risques par famille de solveurs (pour le benchmarking)

Famille de solveurs	Forces (par protocole)	Risques communs
ODE/PDE classiques	Ordres formels dans les régimes lisses; stabilité robuste	Coût par requête supérieur aux substituts neuronaux (metrics spécifiques indisponibles)
ODEs neuronales	Modélisation en temps continu; intégration adaptative	Raideur sans backends implicites; l’erreur du modèle peut limiter l’EOC
PINNs	Bonne gestion des problèmes elliptiques/diffusifs avec un bon poids	Modes d’échec sur les systèmes raides/hyperboliques à moins d’être stabilisés
Opérateurs neuronaux	Forte généralisation de résolution; inférence rapide sur les domaines périodiques	Sensible à l’anti-aliasing/remplissage et les incrustations BC
Pas de temps appris	Peut approcher l’ordre du schéma hôte si cohérent	Risques de dérive hors distribution et à long terme
EDS neuronaux	Ordre fort/faible lié à la discrétisation; statistiques efficaces	Stabilité de formation nécessitant une réduction de la variance (détails spécifiques non fournis)

Bonnes Pratiques

• Standardisez les frontières et le remplissage: Pour les problèmes périodiques et les pipelines d’apprentissage d’opérateur, assurez-vous que le remplissage spectral et le désaliasage sont cohérents pour éviter les gains artificiels.
• Gardez le CFL cohérent: Pour les intégrateurs PDE explicites, adaptez dt avec h; sinon, votre étude de raffinement mélange précision et effets de stabilité.
• Alignez les tolérances: Pour les systèmes raides, utilisez des tolérances implicites alignées en formation et en évaluation; les écarts peuvent créer des plateaux EOC trompeurs.
• Vérifiez d’abord la solidité classique: Confirmez les ordres de jugement de base dans les régimes lisses avant d’introduire des modèles appris; la dégradation près des chocs devrait correspondre à la théorie.
• Reportez à la fois le coût d’inférence et le coût total: Les faux neuronaux brillent dans les régimes à forte inférence, mais la formation peut dominer le coût total; tracez les deux vues Pareto.
• Utilisez des graines et des ICs cohérentes: Exécutez ≥5 graines pour les méthodes apprises et des intervalles de confiance bootstrap; répétez les exécutions classiques adaptatives pour tenir compte de la stochasticité des solveurs et de la variation de planification.
• Documentez tout: Définitions de problèmes, discrétisations, seuils de solveur, préconditionneurs, tailles de modèle, optimiseurs, plannings, matériel, versions logicielles, et graines aléatoires appartiennent à vos configs et README.

Liste de contrôle qualité avant publication:

• Les bases correspondent aux ordres attendus dans les régimes lisses.
• Les convergences des modèles appris incluent ≥3 niveaux de raffinement avec des ICs.
• Les positions Pareto sont validées sous coût d’inférence uniquement et total.
• La stabilité à long terme est validée avec des diagnostics pertinents pour la physique (e.g., spectres, enstrophie).
• Un sous-ensemble est reproduit sur une deuxième machine ou un cloud (étapes matérielles spécifiques non prescrites).

Écueils et sauvegardes:

• Désaliasage/remplissage incohérent dans les pipelines d’opérateur/apprentissage → standardisez les règles.
• CFL non constant durant le raffinement → découplez la stabilité de l’effet de précision.
• Pertes résiduelles déséquilibrées vs les frontières dans les PINNs → envisagez le poids adaptatif/programme.
• Écarts de tolérance durant formation/évaluation sur systèmes raides → alignez ou rapportez les deux.
• Gains apparents qui disparaissent à haute résolution ou entre les graines → vérifiez la robustesse avec le raffinement et plusieurs graines.

Exemples Pratiques

Le protocole inclut des configurations pratiques que vous pouvez appliquer de bout en bout:

• Lorenz-63 (ODE non raide): Fixez T=10 avec un raffinement de pas fixe dt de 1e−2 à 1.25e−3 et une échelle de tolérance pour RK45 adaptatif. Générez une référence de haute précision avec un solveur de haut-ordre ou à tolérance serrée. Entraînez une ODE neurale sur des trajectoires et, à chaque dt/tolérance, calculez les erreurs MSE de l’état terminal et de la trajectoire, EOC, et les comptes de pas. Rapportez le temps mur d’inférence, les FLOPs par pas, et la mémoire; exécutez ≥5 graines et utilisez des ICs bootstrap.

• Van der Pol (μ=1000, ODE raide): Utilisez des références BDF/Radau avec des tolérances serrées via SUNDIALS ou DifferentialEquations.jl. Comparez avec des ODE neurales intégrées par des solveurs implicites (e.g., BDF dans Diffrax). Balayez les tolérances et rapportez l’EOC dans l’erreur de l’état terminal; incluez des comptes d’itération non linéaire et des indicateurs de raideur comme disponible.

• Poisson 2D (elliptique): Choisissez une solution fabriquée sur [0,1]² avec des cas Dirichlet и Neumann. Exécutez FEM (p=1/2) avec un désaffinement h-honorant et le préconditionnement multigrille (HYPRE). Entraînez les variantes DeepONet et PINN. Calculez les erreurs L2/L∞ vs h et l’EOC; pour PINNs, augmentez la densité de collocation et la précision de quadrature; pour les opérateurs, évaluez l’erreur vs la résolution d’évaluation jusqu’à saturation.

• Burgers 1D (hyperbolique): Exécutez un cas de régime lisse et un cas de choc avec des BCs périodiques. Utilisez les bases WENO5 + SSP-RK via Clawpack et calculez l’EOC dans les fenêtres lisses; mesurez l’erreur de temps de choc et la variation totale. Évaluez FNO/PINO et PINNs pour les artefacts de dispersion/Gibbs, appliquez l’anti-aliasing et le remplissage de manière cohérente, et rapportez les taux de stabilité/échec (taux spécifiques indisponibles).

• Navier–Stokes 2D sur un tore: Suivez les configurations FNO/PDEBench; entraînez à 64² et testez à 128², 256². Rapportez la mise à l’échelle des erreurs, la dérive à long terme, les spectres d’énergie, et l’enstrophie en rapport avec les références JAX-CFD.

• Darcy 2D avec BCs mixtes: Générez des champs de perméabilité paramétriques; exécutez les bases FEM et entraînez DeepONet/FNO sur partages PDEBench. Évaluez la généralisation de résolution et les changements de paramètre; rapportez L2/L∞ et l’EOC sous le désaffinement h-honorant.

Ces exemples exploitent chaque composant du protocole—échelles de raffinement, sélection de solveurs, configuration de modèle appris, mesure, profilage de coût et diagnostics de stabilité—tout en restant dans des piles largement utilisées que la communauté reconnaît et peut reproduire.

Conclusion

La convergence reproductible et les comparaisons de Pareto équitables ne se produisent pas par accident; elles sont le produit d’une sélection disciplinée de problèmes, de numériques de qualité référentielle, de raffinements standardisés, de normes d’erreur cohérentes, et d’une comptabilité de coût minutieuse. L’approche DInf-Grid codifie cela pour les ODEs et PDEs sur des grilles structurées et fournit une scène commune sur laquelle les solveurs classiques et appris peuvent être mesurés avec confiance. Avec le guide en 10 étapes ci-dessus—basé sur des librairies numériques matures et des outils de ML largement adoptés—vous pouvez construire des benchmarks qui résistent à l’examen minutieux et informent réellement la sélection du solveur.

À retenir:

• Utilisez des solveurs de référence appropriés à la physique et documentez chaque tolérance, préconditionneur, et maillage/résolution de temps.
• Construisez des échelles de raffinement et calculez l’EOC avec des normes cohérentes et des intervalles de confiance.
• Séparez le coût d’inférence uniquement du coût total (formation + inférence) et tracez les deux vues Pareto.
• Testez la stabilité pour les horizons longs et la généralisation de résolution, en particulier sur flux périodiques et les apprenants d’opérateur.
• Emballez des artefacts complets — configs, journaux, points de contrôle, sorties brutes — pour une vérification externe.

Prochaines étapes: commencez avec un problème par famille d’équation pertinent pour votre application; validez d’abord les bases classiques et l’EOC; puis introduisez des modèles appris avec des régimes d’entraînement clairs et des ablations contrôlées. Une fois que vos graphiques de convergence et de Pareto survivent à des vérifications à haute résolution et plusieurs graines, publiez l’ensemble complet d’artefacts avec un README concis et des instructions de réexécution. C’est comme ça que vos exécutions DInf-Grid seront à la fois utiles et dignes de confiance. ✅

Sources & Références