1. La science dans l’ère de la prédiction

La démarche scientifique s’est construite au fil des siècles selon un schéma bien rodé : observer un phénomène, formuler une hypothèse, concevoir une expérience, mesurer, conclure. Ce cycle reste fondamental, mais une nouvelle brique s’y est ajoutée, et elle change la donne.

Le Deep Learning est une variante du Machine Learning reposant sur des techniques plus complexes, au prix d’un besoin en puissance computationnelle supérieure et de quantités supérieures de données d’entrainement. Le DL permet aujourd’hui de mieux appréhender les données expérimentales complexes pour y déceler des motifs invisibles à l’œil humain, et ainsi en tirer des prédictions quantitatives.

Le cas le plus emblématique est AlphaFold. Développé par les équipes de Google DeepMind, ce modèle prédictif a résolu un problème vieux de cinquante ans en prédisant la structure 3D de protéine à une précision comparable aux méthodes expérimentales[1]. Ce travail a valu à Demis Hassabis et John Jumper le Prix Nobel de Chimie 2024.

D’autres applications sont possibles et explorées : estimer la probabilité qu’une molécule soit toxique, prédire la vitesse d’une réaction chimique, simuler l’évolution d’un système physique, prédire l’action d’une molécule sur une cellule … et le tout sans résoudre manuellement les équations fondamentales qui régissent ces phénomènes.

Mais comment faire confiance à ce type de modèles, quand des pans entiers de la science s’acharnent depuis des années à décrypter ces phénomènes ? Qu’est-ce qui permet aux modèles de décoder les lois de la physico-chimie ?

Pour répondre à cette question, il faut s’intéresser à trois familles d’architectures qui, chacune à leur manière, abordent les données scientifiques sous un angle différent :

L’idée de cet article n’est pas de transformer qui que ce soit en expert de la data science appliquée à la science fondamentale. Mon but est de montrer pourquoi ces outils sont fascinants, et, surtout, comment leur convergence permet la modélisation et la prédiction de systèmes complexes.

Qu’est-ce qu’un réseau de neurones ?

Prenons une fonction mathématique très flexible, capable d’apprendre à associer des entrées (la structure d’une molécule) à des sorties (son point d’ébullition).

Un réseau de neurones est composé de couches successives de « neurones », des unités de calcul simples, qui, ensemble, peuvent approximer des relations extrêmement complexes. Le terme « deep » signifie simplement qu’on empile beaucoup de ces couches.

Ainsi, on peut imaginer un réseau en trois couches pour prédire le point d’ébullition d’une molécule, où chaque couche intègrerait une information différente, chacune avec sa propre importance, son propre paramètre.

La magie, c’est que le réseau ajuste lui-même ses paramètres internes (appelés poids) pour coller au mieux aux données qu’on lui fournit.

Ce processus d’ajustement, c’est ce qu’on appelle l’entraînement. Et on y reviendra !

2. Les RNN pour comprendre les cinétiques temporelles

Prenons une phrase lue mot par mot : chaque nouveau mot prend son sens grâce à ceux qui le précèdent.

Les réseaux de neurones récurrents[2] fonctionnent exactement sur ce principe : ils traitent les données dans un ordre séquentiel, en conservant une « mémoire » des étapes précédentes pour interpréter l’étape en cours.

Techniquement, un RNN maintient un vecteur d’état caché (hidden state) qui se met à jour à chaque pas de temps. C’est cette mémoire interne qui lui permet de capturer des dépendances temporelles, et en d’autres termes, de comprendre que ce qui s’est passé avant influence ce qui va se passer après.

En pseudo-code, le principe fondamental d’un RNN se résume à ceci :

Pour chaque pas de temps t dans la séquence :
    état_caché[t] = activation( W_entrée × donnée[t] + W_récurrence × état_caché[t-1] )
    prédiction[t]  = W_sortie × état_caché[t]

où les matrices W_entrée, W_récurrence et W_sortie sont les poids que le réseau apprend pendant l’entraînement.

L’idée clé est qu’à chaque instant, le réseau combine l’observation actuelle avec le souvenir de tout ce qu’il a vu avant.

Prédire le profil cinétique d’une réaction chimique

En chimie organique, suivre une réaction en temps réel est possible grâce à des techniques de spectroscopies. On obtient alors une “série temporelle” : à chaque instant t correspond une valeur (usuellement la concentration d’un réactif ou d’un produit).

Classiquement, on ajuste ces données à un modèle cinétique (ordre 1, ordre 2, Michaelis-Menten…).

Mais que faire quand la réaction est complexe, multi-étapes, avec des intermédiaires instables ?

C’est là qu’un RNN devient précieux ! La sous-classe des LSTM (Long Short-Term Memory)[3] résout un problème majeur des RNN classiques en permettant au réseau de retenir les informations sur de longues séquences (voir vanishing gradient[4]). D’autres variantes existent, comme le GRU (Gated Recurrent Unit)[5] qui offre une alternative plus légère, avec des performances comparables dans de nombreux cas.

En entraînant un LSTM sur des centaines de profils cinétiques expérimentaux, le réseau apprend à reconnaître les signatures temporelles de différents mécanismes réactionnels. Une fois un modèle entrainé sur notre jeu de données, on peut ainsi lui soumettre les premières minutes d’une nouvelle réaction et il prédira le profil complet, rendement final inclus.

Sans comprendre les mécanismes réactionnels sous-jacents (une activation catalytique au début d’une réaction, la formation d’un produit intermédiaire ou transitoire …), le réseau apprendra ce type de schéma et le restituera.

# --- Prédire la cinétique d'une réaction avec un LSTM ---

Entrée : série_temporelle = [concentration_t0, concentration_t1, ..., concentration_t10]
         # Les 10 premières minutes mesurées par spectroscopie IR in situ

Pour chaque pas de temps t de 0 à 10 :
    (état_caché[t], mémoire[t]) = LSTM(concentration[t], état_caché[t-1], mémoire[t-1])

# Ensuite, le réseau "extrapole" le futur sans nouvelles mesures :
Pour chaque pas de temps t de 11 à 60 :
    concentration_prédite[t] = couche_sortie(état_caché[t-1])
    (état_caché[t], mémoire[t]) = LSTM(concentration_prédite[t], état_caché[t-1], mémoire[t-1])

Sortie : rendement_final = concentration_prédite[60]

La particularité du LSTM par rapport au RNN de base, c’est cette mémoire (le cell state) : un canal d’information protégé qui traverse la séquence entière, permettant au réseau de se souvenir d’un événement survenu au début de la réaction même après des dizaines de pas de temps.

Comment le réseau « apprend »-il ?

On ne programme pas manuellement les poids du réseau, on lui montre des exemples.

Ici, on lui présente des centaines de profils cinétiques dont on connaît les résultats intermédiaires et finaux, puis on le laisse ajuster ses poids pour minimiser l’écart entre ses prédictions et la réalité.

C’est le principe de l’entraînement.

Une bonne analogie chimique correspondrait à l’optimisation des conditions d’une réaction par essai-erreur, sauf que le réseau fait des milliers d’itérations en quelques minutes. Chaque itération réduit un peu l’erreur grâce à un algorithme interne, la descente de gradient.

Ce processus d’entraînement est lié à celui d’optimisation : une part importante de la conception de modèles prédictifs se situe dans le choix et le réglage des hyperparamètres qui gouvernent cet apprentissage.

Intérêt

Le RNN ne suppose rien a priori sur le mécanisme de la réaction, il apprend directement à partir des données. C’est un avantage immense quand on travaille sur des systèmes mal caractérisés ou dans des réactions dont les paramètres changent dynamiquement.

Pourquoi un RNN plutôt qu’une simple régression cinétique ?

En chimie, la réponse classique face à une série temporelle est d’ajuster les données à un modèle mécanistique : loi d’ordre 1, modèle de Michaelis-Menten, système d’équations différentielles couplées… Ces approches sont puissantes quand le mécanisme est connu et le nombre d’intermédiaires limité.

Mais trois situations rendent ce paradigme difficile à appliquer :

La contrepartie est claire : le RNN est un modèle boîte noire. Il prédit sans expliquer. Dans un contexte de chimie fondamentale, où comprendre le mécanisme est souvent l’objectif, cela reste une limitation importante.

Notons qu’une évolution majeure des architectures séquentielles a vu le jour avec les Transformers[6], qui remplacent la récurrence par des mécanismes d’attention. Schwaller et al. ont d’ailleurs montré que le Molecular Transformer, appliqué aux représentations SMILES[7] de réactifs, atteint plus de 90 % de précision dans la prédiction de produits de réaction[8]. Cette avancée spectaculaire traite la chimie organique comme un problème de traduction automatique, similaire aux modèles d’IA générative omniprésents depuis quelques années.

Le problème est que ce type d’approche voit les molécules comme des séquences de caractères (via les notations SMILES, par exemple : CC(=O)O pour l’acide acétique). Or, une molécule n’est pas qu’une suite de lettres mais un réseau d’atomes connectés ! Et pour capturer cette structure, il faut un autre outil…

3. Les GNN pour comprendre la structure des molécules

En Deep Learning, les molécules sont représentées comme des assemblages d’atomes reliés par des liaisons (donc des nœuds reliés par des arêtes), dans une structure correspondant à un graphe[9].

Les Graph Neural Networks, dans un contexte chimique, prennent en entrée un graphe moléculaire où chaque atome possède des caractéristiques (type d’élément, charge, hybridation…), et chaque liaison également (type, longueur …). Le réseau apprend ensuite une représentation numérique de la molécule (un vecteur, appelé embedding) qui encode sa structure de manière à prédire une propriété cible.

La bibliothèque RDKit[16] permet de convertir aisément des représentations SMILES en graphes moléculaires exploitables par ces architectures, tandis que des frameworks comme PyTorch Geometric[17] offrent les briques de base pour construire et entraîner ces modèles.

Comment passe-t-on d’un SMILES à un graphe exploitable par un réseau ?

Cette étape de prétraitement fondamentale ressemble à ceci :

# --- Transformer une molécule en graphe ---

smiles = "CC(=O)Oc1ccccc1C(=O)O"   # Aspirine, en notation SMILES
molécule = convertir_smiles_en_objet(smiles)   # via RDKit [16]

Pour chaque atome dans molécule :
    caractéristiques_atome = [type_élément, nb_liaisons, charge_formelle,
                              hybridation, aromatique_oui_non]
    ajouter_noeud(graphe, caractéristiques_atome)

Pour chaque liaison dans molécule :
    caractéristiques_liaison = [type_liaison, conjuguée_oui_non, dans_cycle_oui_non]
    ajouter_arête(graphe, atome_1, atome_2, caractéristiques_liaison)

Sortie : graphe moléculaire prêt pour le GNN

Le cœur d’un GNN repose sur un principe élégant formalisé par Gilmer et al. sous le nom de Message Passing Neural Networks (MPNN)[10]. À chaque couche du réseau, chaque atome « communique » avec ses voisins directs : le passage de messages. Il agrège leurs informations, les combine avec les siennes, et met à jour sa propre représentation.

Chaque atome a intégré l’information de son voisinage élargi après plusieurs tours de message passing. On agrège ensuite l’ensemble des représentations atomiques pour obtenir un vecteur global de la molécule, le graph-level embedding. Ce dernier peut ensuite être utilisé pour une tâche de prédiction.

# --- Une couche de message passing ---

Pour chaque atome i dans le graphe :
    messages = []
    Pour chaque voisin j de l'atome i :
        message_j = réseau_message(état[j], liaison[i,j])
        messages.ajouter(message_j)

    messages_agrégés = somme(messages)   # ou moyenne, ou max
    état[i] = réseau_mise_à_jour(état[i], messages_agrégés)

# Après K couches de message passing :
embedding_molécule = agrégation_globale( [état[i] pour chaque atome i] )
propriété_prédite  = couche_finale(embedding_molécule)

où réseau_message et réseau_mise_à_jour sont eux-mêmes de petits réseaux de neurones dont les poids sont appris pendant l’entraînement.

Des architectures comme SchNet[11] et DimeNet[12] vont plus loin en intégrant les distances interatomiques et les angles de liaison, capturant ainsi la géométrie 3D des molécules. Plus récemment, des modèles comme PaiNN[13] exploitent des représentations équivariantes qui respectent les symétries physiques du système.

Prédiction de propriétés et d’activités (QSAR/QSPR)

Un GNN entraîné peut apprendre à associer des sous-structures moléculaires à l’activité biologique, comme dans le projet BioGNN. Entre autres, les motifs chimiques deviennent des « signaux » que le réseau détecte et exploite. Coley et al. ont démontré dès 2019 qu’un réseau convolutif sur graphes pouvait prédire la réactivité chimique directement à partir de la structure moléculaire[15].

Ces réseaux permettent ainsi de cribler in silico des millions de candidats en quelques heures, là où le screening expérimental prendrait des mois. Et la puissance du GNN, c’est qu’il ne nécessite aucun feature engineering manuel : il découvre seul les descripteurs pertinents directement depuis la structure de la molécule.

Comment sait-on si un modèle est bon ?

En chimie, quand on développe une méthode analytique, on la valide avec des échantillons dont on connaît la réponse.

En machine learning, c’est pareil.

On découpe son jeu de données en trois parties :

  • un jeu d’entraînement (70–80 % des données) sur lequel le modèle apprend;

  • un jeu de validation (10–15 %) pour ajuster les réglages du modèle (les hyperparamètres);

  • et un jeu de test (10–15 %) qu’on ne montre au modèle qu’à la toute fin, pour mesurer sa performance réelle sur des données inédites.

Si le modèle est très bon sur l’entraînement mais mauvais sur le test, on dit qu’il a fait du surapprentissage (overfitting) : il a appris par coeur les exemples au lieu d’en extraire les règles générales.

Dans le cas idéal, on veut un modèle qui généralise : il doit être capable de faire de bonnes prédictions même sur des molécules qu’il n’a jamais vues.

Les GNN capturent admirablement la topologie moléculaire. Mais ils restent pour autant des modèles purement data-driven : ils ne « savent » pas que l’énergie se conserve, qu’une concentration ne peut pas être négative, ou qu’une réaction obéit au second principe de la thermodynamique. Et si on pouvait injecter cette connaissance fondamentale directement dans le réseau ?

4. Les PINN : quand la physique guide l’apprentissage

Les PINN, Physics-Informed Neural Networks, permettent de répondre à deux problématiques inhérentes aux réseaux de neurones classiques :

L’idée des Physics-Informed Neural Networks, introduite par Raissi, Perdikaris et Karniadakis[18], est aussi simple que brillante : on ne demande pas au réseau d’apprendre uniquement à partir des données : on lui demande aussi de respecter les lois physiques connues. En pratique, cela revient à modifier la fonction de coût (la loss function, le critère que le réseau cherche à minimiser pendant l’entraînement), en lui imposant des valeurs via des fonctions mathématiques dérivées des lois physiques.

La fonction de coût, c’est quoi exactement ?

C’est le « juge » du réseau de neurones.

À chaque itération d’entraînement, le réseau fait une prédiction, et la fonction de coût mesure à quel point cette prédiction est loin de la réalité. Plus la valeur est faible, meilleur est le modèle.

L’entraînement consiste donc à chercher les poids qui minimisent cette fonction, comme on chercherait le minimum d’énergie d’un système moléculaire. C’est d’ailleurs le même type de mathématiques : une optimisation dans un espace à très haute dimensionnalité.

Un réseau de neurones classique minimise l’écart entre ses prédictions et les observations expérimentales. Un PINN ajoute un second terme à cette fonction de coût : la violation des équations physiques.

Supposons qu’on veuille modéliser la diffusion d’un réactif dans un milieu poreux. Le phénomène est décrit par l’équation de diffusion-réaction :

\[\frac{\partial C}{\partial t} = D \nabla^2 C - k \cdot C\]

où C est la concentration, D le coefficient de diffusion, et k la constante de vitesse de dégradation.

Un PINN prend en entrée les coordonnées spatiales et temporelles (x, y, z, t), prédit la concentration C, puis calcule automatiquement (grâce à la différentiation automatique[19], outil natif dans PyTorch[20] et TensorFlow) les dérivées partielles nécessaires. Le résidu de l’équation, l’écart entre le membre de gauche et le membre de droite, est ajouté à la loss.

# --- Entraînement d'un PINN pour la diffusion-réaction ---

réseau = créer_réseau_neurones(entrées=4, sorties=1)    # (x, y, z, t) → C
données_exp = charger_mesures_concentration()             # points expérimentaux rares

Pour chaque itération d'entraînement :

    # 1. Loss sur les données expérimentales
    C_prédit = réseau(x_exp, y_exp, z_exp, t_exp)
    loss_données = moyenne( (C_prédit - C_mesuré)² )

    # 2. Loss physique : le réseau doit respecter l'équation de diffusion-réaction
    #    On évalue l'équation en des milliers de points "fictifs" (points de collocation)
    (x, y, z, t) = générer_points_aléatoires_dans_le_domaine()
    C = réseau(x, y, z, t)

    dC_dt   = dérivée_automatique(C, t)       # ∂C/∂t
    d2C_dx2 = dérivée_automatique_seconde(C, x) # ∂²C/∂x²  (idem pour y, z)

    résidu_physique = dC_dt - D * (d2C_dx2 + d2C_dy2 + d2C_dz2) + k * C
    loss_physique = moyenne( résidu_physique² )

    # 3. Loss totale
    loss_totale = loss_données + λ × loss_physique

    # 4. Mise à jour des poids (descente de gradient)
    ajuster_poids(réseau, loss_totale)

Point crucial : les points_aléatoires_dans_le_domaine ne sont pas des mesures expérimentales mais des points où le réseau doit simplement respecter l’équation. On peut en générer autant que nécessaire, sans aucun coût expérimental. C’est ce mécanisme qui permet au PINN de produire des prédictions physiquement cohérentes même avec très peu de données réelles.

Là où un réseau classique aurait besoin de milliers d’exemples, un PINN peut se contenter de quelques centaines, justement parce que les équations physiques agissent comme un régularisateur extrêmement puissant ! Karniadakis et al. ont montré dans une étude approfondie que cette approche offre un cadre unificateur pour la modélisation scientifique à l’intersection de la physique et du machine learning[21].

Et l’intérêt bonus des PINN, c’est qu’ils peuvent résoudre des problèmes inverses ! À partir de données observées, ils estiment les paramètres physiques inconnus (comme D ou k dans notre exemple). On passe alors de la prédiction à la découverte de lois.

La différence est subtile mais puissante :

# --- Problème inverse : découvrir les paramètres physiques ---

# D et k ne sont plus des constantes fixées,
# mais des paramètres APPRENABLES au même titre que les poids du réseau
D = paramètre_apprenable(valeur_initiale=0.1)
k = paramètre_apprenable(valeur_initiale=0.01)

# Le reste de l'entraînement est identique.
# Le réseau ajuste simultanément :
#   - ses poids internes (pour approximer C)
#   - les paramètres D et k (pour satisfaire l'équation physique)

Sortie : D_estimé = 0.042, k_estimé = 0.0037
         # → Le réseau a "découvert" les paramètres physiques du système !

Des frameworks comme DeepXDE[22] facilitent considérablement l’implémentation de ces modèles, rendant les PINN accessibles aux chercheurs non spécialistes du deep learning.

Les PINN travaillent donc sur des champs continus (concentration, température, pression), et ne « comprennent » pas nativement à quoi correspond une molécule ou une séquence temporelle.

… et si on combinait les trois approches que nous venons de voir ?

5. Pipeline complet pour la chimie prédictive

Prenons un cas concret à l’intersection de la chimie et du machine learning.

Un laboratoire travaille sur une réaction photocatalytique en microréacteur à flux continu[23]. Dans ce procédé, un mélange réactionnel circule dans un tube transparent, irradié par une source lumineuse, avec un photocatalyseur en solution.

L’objectif est de maximiser le rendement du produit souhaité tout en minimisant la formation de sous-produits. Les variables sont nombreuses : structure du substrat, choix du catalyseur, longueur d’onde, temps de résidence, concentration, température, solvant …

Voici comment les trois architectures se complètent dans un pipeline intégré :

Étape 1 : Le GNN encode la chimie. On représente chaque substrat et chaque catalyseur sous forme de graphe moléculaire. Un GNN pré-entraîné génère un embedding pour chaque molécule : un vecteur dense qui capture ses propriétés structurales et électroniques. C’est la « carte d’identité numérique » de chaque composé.

Étape 2 : Le RNN capture la dynamique du procédé. En flux continu, les capteurs enregistrent en temps réel l’évolution de la conversion (par spectroscopie inline). Un LSTM entraîné sur des centaines d’expériences passées prend en entrée la séquence temporelle des mesures et les embeddings moléculaires issus du GNN. Il prédit l’évolution du rendement et détecte précocement les dérives, comme l’apparition d’un sous-produit inattendu ou la désactivation progressive du catalyseur.

Étape 3 : Le PINN assure la cohérence physique. Le système est contraint par les lois de la photochimie : la loi de Beer-Lambert, les bilans de matière dans le réacteur, la thermodynamique des états excités. Un PINN prend les prédictions du RNN et les « filtre » à travers ces équations, garantissant que le modèle ne viole jamais les principes fondamentaux, et ce même dans des régions de l’espace des paramètres peu couvertes par les données.

# --- Pipeline intégré : GNN + LSTM + PINN ---

# ÉTAPE 1 : Encoder les molécules (une seule fois par substrat/catalyseur)
graphe_substrat    = smiles_vers_graphe("c1ccc(/C=C/C=O)cc1")    # Cinnamaldéhyde
graphe_catalyseur  = smiles_vers_graphe("[Ru+2](n1ccccc1-c1ccccn1)(n1ccccc1-c1ccccn1)n1ccccc1-c1ccccn1")   # Ru(bpy)₃²⁺
emb_substrat       = GNN_pré_entraîné(graphe_substrat)           # vecteur 128D
emb_catalyseur     = GNN_pré_entraîné(graphe_catalyseur)         # vecteur 128D

# ÉTAPE 2 : Prédire la dynamique du procédé
conditions = [λ=450nm, T=25°C, débit=0.5mL/min, conc=0.1M]
entrée_lstm = combiner(emb_substrat, emb_catalyseur, conditions)

Pour chaque pas de temps t :
    (rendement_prédit[t], état) = LSTM(entrée_lstm, mesure_inline[t], état)

# ÉTAPE 3 : Filtrer par la physique
Pour chaque prédiction du LSTM :
    vérifier : Beer-Lambert     → A = ε × l × C          ✓ ou correction
    vérifier : bilan de matière → Σ(espèces) = constante  ✓ ou correction
    vérifier : ΔG < 0 pour la direction de réaction        ✓ ou correction
    rendement_corrigé[t] = PINN(rendement_prédit[t], contraintes_physiques)

Sortie : profil_rendement_optimisé, conditions_optimales

On obtient alors un jumeau numérique du procédé : un modèle capable de simuler le comportement du réacteur pour n’importe quelle combinaison substrat/catalyseur/conditions, en quelques secondes au lieu de quelques jours d’expérimentation.

L’optimisation peut alors être automatisée par des algorithmes de recherche (optimisation bayésienne[25], par exemple), réduisant drastiquement le nombre d’expériences nécessaires.

Note sur ce pipeline : l’intégration présentée ici (et en particulier le couplage LSTM → PINN à l’étape 3) est une illustration conceptuelle, pas un workflow clé-en-main.

Dans la pratique, connecter ces trois architectures dans un pipeline cohérent reste un problème ouvert de recherche. L’entraînement conjoint de composants hétérogènes soulève des questions non triviales : comment équilibrer les contributions de chaque loss ? Comment propager les gradients à travers des modules appris séparément ?

Ces défis font l’objet de travaux actifs dans la littérature de ML scientifique. Ce que ce pipeline illustre, en revanche, est tout à fait réel : la complémentarité des trois paradigmes, et le fait que les briques existent indépendamment.

Et la beauté dans tout ça, c’est que ce n’est pas un futur hypothétique ! Les briques technologiques existent toutes aujourd’hui : PyTorch[20] pour l’entraînement, Optuna pour l’optimisation, RDKit[16] pour le traitement des graphes moléculaires, DeepXDE[22] pour les PINN, et les frameworks de chimie de flux pour la génération de données.

Ce qui manque encore, c’est l’intégration systématique de ces outils. Et c’est précisément là que la data science appliquée à la chimie a un rôle crucial à jouer.

💡 Le cycle de vie complet d’un projet de deep learning

Les pseudo-codes ci-dessus montrent les architectures, mais un projet réel de machine learning comporte bien d’autres étapes :

1. Collecte des données : Rassembler les données expérimentales (bases publiques, cahiers de labo, spectres…). C’est souvent l’étape la plus longue, la plus sous-estimée, et … la moins aimée.

2. Prétraitement : Nettoyer les données, gérer les valeurs manquantes, normaliser les échelles, convertir les SMILES en graphes.

3. Choix de l’architecture : RNN, GNN, PINN ou une combinaison ? Cela dépend de la nature des données et de la question posée.

4. Optimisation du modèle : Le moment où l’on fait chauffer sa machine ! Choix des hyperparamètres (nombre de couches, taille des embeddings, taux d’apprentissage), régularisation pour éviter le surapprentissage, et validation croisée pour évaluer la robustesse du modèle.

5. Entraînement : Le réseau ajuste ses poids sur le jeu d’entraînement, itération après itération (on parle d’époques). On surveille la performance sur le jeu de validation pour savoir quand s’arrêter.

6. Évaluation : On mesure la performance finale sur le jeu de test. Les métriques classiques : MAE (erreur absolue moyenne), RMSE (racine de l’erreur quadratique moyenne), adj-R² (coefficient de détermination ajusté).

7. Déploiement : Rendre le modèle utilisable dans un pipeline de production ou un outil d’aide à la décision.

Ce cycle est itératif : si les performances ne sont pas satisfaisantes, on revient en arrière. Exactement comme on retourne à la paillasse quand un résultat n’est pas reproductible.

6. Conclusion

Le deep learning ne remplace pas l’expertise du chimiste. Il ne rend pas obsolètes les années passées à comprendre les mécanismes réactionnels, à développer l’intuition du laboratoire, à maîtriser la spectroscopie. Ce qu’il fait, c’est amplifier cette expertise.

Un RNN peut détecter un pattern cinétique que l’œil humain aurait mis des semaines à identifier. Un GNN peut explorer un espace chimique de millions de molécules en quelques heures. Un PINN peut extraire les paramètres physiques d’un système à partir de données incomplètes.

Mais aucun de ces outils ne fonctionne sans la personne qui pose la bonne question, qui conçoit le bon jeu de données, et qui interprète les résultats avec le recul du domaine.

Bien sûr, des défis importants restent à relever !

L’interprétabilité des modèles demeure un enjeu majeur[26] : comment s’assurer que le réseau a appris les bonnes corrélations et non des artefacts du dataset ? La reproductibilité des résultats en machine learning scientifique fait l’objet d’un débat actif et nécessaire[27], et l’empreinte environnementale de l’entraînement de ces modèles doit s’inscrire dans une démarche cohérente avec la chimie durable défendue[28].

Ce qui rend cette convergence particulièrement prometteuse pour la chimie, c’est qu’elle ne réduit pas le scientifique à un utilisateur de boîtes noires. Un RNN mal entraîné qui prédit une cinétique aberrante, un qui GNN apprend une corrélation structurale qui n’a pas de sens électronique, ou un PINN qui viole le bilan de matière,autant d’exemples qui sauteraient aux yeux d’un chimiste et de sa connaissance du domaine.

À chaque étape, l’expertise du domaine reste le garde-fou. Ce n’est pas une contrainte, mais précisément ce qui donne de la valeur au résultat.

Et la suite ?

Cet article a présenté les idées derrière ces architectures. Mais comme souvent lorsqu’on appréhende de nouveaux concepts, on peut ressortir de la leçon avec plus de questions qu’au début.

Donc, concrètement, comment ça se code ? Comment entraîne-t-on réellement un GNN sur des données moléculaires ? Combien de données faut-il ? Quel matériel ? Combien de temps ça prend ?

Dans un prochain article, on mettra les mains dans le code. On partira d’un jeu de données moléculaires réel, on construira un GNN pas à pas en Python avec PyTorch, et on suivra ensemble tout le cycle de développement : du prétraitement des SMILES jusqu’à l’évaluation du modèle.

L’occasion de démystifier des termes comme batch size, learning rate, epoch, loss curve, et de montrer qu’avec les bons outils, un scientifique curieux peut aller très loin, même sans background important en informatique.

En attendant, vous pouvez consulter ce projet qui vise à exploiter des GNNs pour prédire les propriétés photophysiques de photocatalyseurs.

Si vous voulez être notifié de sa publication, suivez-moi sur LinkedIn, ou abonnez-vous au flux RSS.

Références

  1. « Highly accurate protein structure prediction with AlphaFold », Jumper J., Evans R., Pritzel A. et al., Nature, 2021, vol. 596, n° 7873, pp. 583–589. DOI : 10.1038/s41586-021-03819-2

  2. « Learning representations by back-propagating errors », Rumelhart D. E., Hinton G. E., Williams R. J., Nature, 1986, vol. 323, n° 6088, pp. 533–536. DOI : 10.1038/323533a0

  3. « Long Short-Term Memory », Hochreiter S., Schmidhuber J., Neural Computation, 1997, vol. 9, n° 8, pp. 1735–1780. DOI : 10.1162/neco.1997.9.8.1735

  4. « Learning long-term dependencies with gradient descent is difficult », Bengio Y., Simard P., Frasconi P., IEEE Transactions on Neural Networks, 1994, vol. 5, n° 2, pp. 157–166. DOI : 10.1109/72.279181

  5. « Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation », Cho K., van Merriënboer B., Gulcehre C. et al., EMNLP, 2014, pp. 1724–1734. DOI : 10.3115/v1/D14-1179

  6. « Attention Is All You Need », Vaswani A., Shazeer N., Parmar N. et al., NeurIPS, 2017, vol. 30, pp. 5998–6008.

  7. « SMILES, a chemical language and information system », Weininger D., Journal of Chemical Information and Computer Sciences, 1988, vol. 28, n° 1, pp. 31–36. DOI : 10.1021/ci00057a005

  8. « Molecular Transformer: A Model for Uncertainty-Calibrated Chemical Reaction Prediction », Schwaller P., Laino T., Gaudin T. et al., ACS Central Science, 2019, vol. 5, n° 9, pp. 1572–1583. DOI : 10.1021/acscentsci.9b00576

  9. « Geometric Deep Learning: Grids, Groups, Graphs, Geodesics, and Gauges », Bronstein M. M., Bruna J., Cohen T., Veličković P., arXiv, 2021. arXiv : 2104.13478

  10. « Neural Message Passing for Quantum Chemistry », Gilmer J., Schoenholz S. S., Riley P. F., Vinyals O., Dahl G. E., ICML, 2017, vol. 70, pp. 1263–1272.

  11. « SchNet: A continuous-filter convolutional neural network for modeling quantum interactions », Schütt K. T., Kindermans P.-J., Sauceda H. E. et al., NeurIPS, 2017, vol. 30, pp. 991–1001.

  12. « Directional Message Passing for Molecular Graphs », Gasteiger J., Groß J., Günnemann S., ICLR, 2020.

  13. « Equivariant message passing for the prediction of tensorial properties and molecular spectra », Schütt K. T., Unke O. T., Gastegger M., ICML, 2021, vol. 139, pp. 9377–9388.

  14. « ChEMBL: towards direct deposition of bioassay data », Mendez D., Gaulton A., Bento A. P. et al., Nucleic Acids Research, 2019, vol. 47, n° D1, pp. D930–D940. DOI : 10.1093/nar/gky1075

  15. « A graph-convolutional neural network model for the prediction of chemical reactivity », Coley C. W., Jin W., Rogers L. et al., Chemical Science, 2019, vol. 10, n° 2, pp. 370–377. DOI : 10.1039/C8SC04228D

  16. « RDKit: Open-source cheminformatics », Landrum G., 2016. URL : rdkit.org

  17. « Fast Graph Representation Learning with PyTorch Geometric », Fey M., Lenssen J. E., ICLR Workshop on Representation Learning on Graphs and Manifolds, 2019.

  18. « Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations », Raissi M., Perdikaris P., Karniadakis G. E., Journal of Computational Physics, 2019, vol. 378, pp. 686–707. DOI : 10.1016/j.jcp.2018.10.045

  19. « Automatic Differentiation in Machine Learning: A Survey », Baydin A. G., Pearlmutter B. A., Radul A. A., Siskind J. M., Journal of Machine Learning Research, 2018, vol. 18, n° 153, pp. 1–43.

  20. « PyTorch: An Imperative Style, High-Performance Deep Learning Library », Paszke A., Gross S., Massa F. et al., NeurIPS, 2019, vol. 32, pp. 8024–8035.

  21. « Physics-informed machine learning », Karniadakis G. E. et al., Nature Reviews Physics, 2021, vol. 3, n° 6, pp. 422–440. DOI : 10.1038/s42254-021-00314-5

  22. « DeepXDE: A deep learning library for solving differential equations », Lu L., Meng X., Mao Z., Karniadakis G. E., SIAM Review, 2021, vol. 63, n° 1, pp. 208–228. DOI : 10.1137/19M1274067

  23. « Applications of Continuous-Flow Photochemistry in Organic Synthesis, Material Science, and Water Treatment », Cambié D. et al., Chemical Reviews, 2016, vol. 116, n° 17, pp. 10276–10341. DOI : 10.1021/acs.chemrev.5b00707

  24. « PubChem in 2021: new data content and improved web interfaces », Kim S. et al., Nucleic Acids Research, 2021, vol. 49, n° D1, pp. D1388–D1395. DOI : 10.1093/nar/gkaa971

  25. « Bayesian reaction optimization as a tool for chemical synthesis », Shields B. J. et al., Nature, 2021, vol. 590, n° 7844, pp. 89–96. DOI : 10.1038/s41586-021-03213-y

  26. « Drug discovery with explainable artificial intelligence », Jiménez-Luna J., Grisoni F., Schneider G., Nature Machine Intelligence, 2020, vol. 2, n° 10, pp. 573–584. DOI : 10.1038/s42256-020-00236-4

  27. « Reproducibility in machine learning for chemistry », Clymo J. et al., Digital Discovery, 2024, vol. 3, pp. 2377–2392. DOI : 10.1039/D4DD00248B

  28. « Green AI », Schwartz R. et al., Communications of the ACM, 2020, vol. 63, n° 12, pp. 54–63. DOI : 10.1145/3381831