LLM et IA Générative
IA et Science
Révolutions scientifiques par l'IA - AlphaFold, prédiction météo, découverte de médicaments et modélisation climatique
IA et Science
L'intelligence artificielle transforme la recherche scientifique. De la biologie à la climatologie, des découvertes majeures sont désormais possibles grâce aux modèles d'IA.
AlphaFold : la révolution des protéines
Le problème du repliement
┌─────────────────────────────────────────────────────────────────┐
│ LE DÉFI DU REPLIEMENT DES PROTÉINES │
├─────────────────────────────────────────────────────────────────┤
│ │
│ SÉQUENCE D'ACIDES AMINÉS STRUCTURE 3D │
│ (connue depuis 1950s) (difficile à prédire) │
│ │
│ M-A-L-W-M-R-L-L-P-L... → ????? │
│ │
│ Le paradoxe de Levinthal: │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Une protéine de 100 acides aminés pourrait adopter │ │
│ │ 10^300 configurations possibles │ │
│ │ │ │
│ │ En testant 1 trillion/seconde, il faudrait plus de │ │
│ │ temps que l'âge de l'univers pour toutes les explorer │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ MÉTHODES EXPÉRIMENTALES: │
│ - Cristallographie aux rayons X: 6 mois à plusieurs années │
│ - Cryo-EM: quelques semaines à mois │
│ - Coût: 100 000$ à 1 000 000$ par structure │
│ │
└─────────────────────────────────────────────────────────────────┘Architecture d'AlphaFold 2
┌─────────────────────────────────────────────────────────────────┐
│ ARCHITECTURE ALPHAFOLD 2 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ INPUT: Séquence d'acides aminés │
│ M-A-L-W-M-R-L-L-P-L-L-A-L-L-A-L-W-G-P... │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────┐ │
│ │ RECHERCHE DE SÉQUENCES │ │
│ │ SIMILAIRES (MSA) │ │
│ │ Base: UniRef, BFD, MGnify │ │
│ └─────────────────────────────────────┘ │
│ │ │
│ ┌────────────┴────────────┐ │
│ ▼ ▼ │
│ ┌───────────────────┐ ┌───────────────────┐ │
│ │ Evoformer │ │ Templates │ │
│ │ (48 blocs) │◄────►│ (structures │ │
│ │ Attention sur │ │ connues) │ │
│ │ paires + MSA │ │ │ │
│ └─────────┬─────────┘ └───────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────────────┐ │
│ │ STRUCTURE MODULE │ │
│ │ Prédiction des coordonnées 3D │ │
│ │ + scores de confiance (pLDDT) │ │
│ └───────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ OUTPUT: Structure 3D avec confiance par résidu │
│ │
└─────────────────────────────────────────────────────────────────┘Utiliser AlphaFold
# Option 1: AlphaFold Database (200M+ structures)
# https://alphafold.ebi.ac.uk/
import requests
def get_alphafold_structure(uniprot_id: str) -> dict:
"""Récupère une structure depuis la base AlphaFold"""
base_url = "https://alphafold.ebi.ac.uk/api/prediction"
response = requests.get(f"{base_url}/{uniprot_id}")
if response.status_code == 200:
data = response.json()[0]
return {
"pdb_url": data["pdbUrl"],
"confidence_url": data["paeImageUrl"],
"sequence_length": data["uniprotEnd"],
}
return None
# Exemple: Hémoglobine humaine
structure = get_alphafold_structure("P69905")
print(f"Structure PDB: {structure['pdb_url']}")
# Option 2: ColabFold (AlphaFold accessible)
# https://colab.research.google.com/github/sokrypton/ColabFold
"""
1. Ouvrir ColabFold sur Google Colab
2. Coller votre séquence
3. Exécuter (gratuit avec GPU)
4. Télécharger la structure prédite
"""
# Option 3: ESMFold (Meta) - Plus rapide
from transformers import AutoTokenizer, EsmForProteinFolding
tokenizer = AutoTokenizer.from_pretrained("facebook/esmfold_v1")
model = EsmForProteinFolding.from_pretrained("facebook/esmfold_v1")
sequence = "MLSRAVCGTSRQLAPVLAYLGSRQKHSLPDLPYDYGALEPHIN"
inputs = tokenizer([sequence], return_tensors="pt", add_special_tokens=False)
with torch.no_grad():
outputs = model(**inputs)
# outputs.positions contient les coordonnées 3DImpact scientifique
┌─────────────────────────────────────────────────────────────────┐
│ IMPACT D'ALPHAFOLD │
├─────────────────────────────────────────────────────────────────┤
│ │
│ AVANT ALPHAFOLD (2020): APRÈS ALPHAFOLD: │
│ ~180,000 structures 200,000,000+ structures │
│ connues expérimentalement prédites (quasi tout le vivant) │
│ │
│ APPLICATIONS: │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 💊 DÉCOUVERTE DE MÉDICAMENTS │ │
│ │ Identifier des sites de liaison │ │
│ │ Designer des molécules ciblées │ │
│ │ Exemple: Antipaludéens en développement │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ 🧬 COMPRÉHENSION DES MALADIES │ │
│ │ Mutations et leur effet structural │ │
│ │ Exemple: Variants du SARS-CoV-2 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ 🌱 BIOTECHNOLOGIE │ │
│ │ Enzymes pour biocarburants │ │
│ │ Plastiques biodégradables │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ 🔬 BIOLOGIE FONDAMENTALE │ │
│ │ Comprendre l'évolution │ │
│ │ Interactions protéine-protéine │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ Prix Nobel de Chimie 2024: Demis Hassabis et John Jumper │
│ │
└─────────────────────────────────────────────────────────────────┘Prédiction météorologique
L'IA surpasse les modèles physiques
┌─────────────────────────────────────────────────────────────────┐
│ MÉTÉO: PHYSIQUE vs INTELLIGENCE ARTIFICIELLE │
├─────────────────────────────────────────────────────────────────┤
│ │
│ MODÈLES PHYSIQUES (NWP) MODÈLES IA │
│ ┌─────────────────────┐ ┌─────────────────────┐ │
│ │ Équations de Navier-│ │ Réseaux de neurones │ │
│ │ Stokes, thermo- │ │ entraînés sur │ │
│ │ dynamique, etc. │ │ 40 ans de données │ │
│ │ │ │ │ │
│ │ Temps: 1h sur │ │ Temps: 1 minute │ │
│ │ supercomputer │ │ sur 1 GPU │ │
│ │ │ │ │ │
│ │ Énergie: ~50 MW │ │ Énergie: ~500 W │ │
│ └─────────────────────┘ └─────────────────────┘ │
│ │
│ COMPARAISON (prévision 10 jours): │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Modèle │ RMSE Temp │ ACC 500hPa │ Temps calc │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ IFS (ECMWF) │ 2.1°C │ 0.72 │ ~1 heure │ │
│ │ GraphCast │ 1.9°C │ 0.75 │ <1 min │ │
│ │ Pangu-Weather │ 1.95°C │ 0.74 │ ~10 sec │ │
│ │ GenCast │ 1.8°C │ 0.77 │ <1 min │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘GraphCast (Google DeepMind)
# GraphCast - Modèle météo de DeepMind
# Entraîné sur ERA5 (ECMWF), 1979-2017
"""
Architecture: Graph Neural Network
- La Terre = graphe avec ~1M de noeuds
- Résolution: 0.25° (~28km)
- Variables: 227 (température, pression, vent, humidité...)
- Niveaux: 37 niveaux de pression
"""
# Utilisation via Google Cloud
from google.cloud import aiplatform
def forecast_weather(initial_conditions):
"""
Prévision météo avec GraphCast
input: conditions initiales (ERA5 format)
output: prévision 10 jours, pas de 6h
"""
endpoint = aiplatform.Endpoint(
endpoint_name="projects/PROJECT/locations/us-central1/endpoints/graphcast"
)
response = endpoint.predict(instances=[initial_conditions])
return response.predictions
# Les données ERA5 sont disponibles gratuitement
# https://cds.climate.copernicus.eu/Aurora (Microsoft)
┌─────────────────────────────────────────────────────────────────┐
│ MICROSOFT AURORA │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Foundation Model pour les sciences de la Terre │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Données historiques ┌────────────────────────┐ │ │
│ │ (1M+ heures) ───► │ │ │ │
│ │ │ AURORA │ │ │
│ │ Données satellites ───►│ (1.3B paramètres) │ │ │
│ │ (temps réel) │ │ │ │
│ │ └────────────────────────┘ │ │
│ │ │ │ │
│ │ ┌──────────────────────┼──────────────┐ │ │
│ │ ▼ ▼ ▼ │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐│ │
│ │ │ Météo │ │Qualité │ │ Océan ││ │
│ │ │ 10 jours │ │ de l'air │ │ ││ │
│ │ └──────────┘ └──────────┘ └──────────┘│ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ Avantages: │
│ - 5000x plus rapide que modèles traditionnels │
│ - Résolution 0.1° (~11km) │
│ - Multi-tâches (météo, pollution, vagues) │
│ │
└─────────────────────────────────────────────────────────────────┘Découverte de médicaments
IA dans le drug discovery
┌─────────────────────────────────────────────────────────────────┐
│ PIPELINE DE DÉCOUVERTE DE MÉDICAMENTS │
├─────────────────────────────────────────────────────────────────┤
│ │
│ TRADITIONNEL: 10-15 ans, $2.6 milliards │
│ │
│ 1. Identification 2. Optimisation 3. Tests 4. Clinique │
│ cible (2-3 ans) (3-5 ans) préclin. (6-8 ans) │
│ ┌──────────┐ ┌──────────┐ ┌────────┐ ┌──────────┐ │
│ │ │──────►│ │──►│ │─►│ │ │
│ └──────────┘ └──────────┘ └────────┘ └──────────┘ │
│ │
│ AVEC IA: Potentiellement 4-5 ans, <$500M │
│ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ AlphaFold ───► Structure 3D cible │ │
│ │ MolGPT ───► Génération de molécules │ │
│ │ ADMET-AI ───► Prédiction toxicité │ │
│ │ Simulations ───► Tests in-silico │ │
│ │ │ │
│ └────────────────────────────────────────────────────────┘ │
│ │
│ EXEMPLES RÉELS: │
│ - Insilico Medicine: candidat en Phase 2 en 2.5 ans │
│ - Recursion: 500+ programmes de découverte actifs │
│ - Isomorphic Labs (DeepMind): partenariats $3B+ │
│ │
└─────────────────────────────────────────────────────────────────┘Génération de molécules
# Génération de molécules avec IA
# Exemple conceptuel utilisant RDKit et modèle génératif
from rdkit import Chem
from rdkit.Chem import AllChem, Descriptors
import torch
class MoleculeGenerator:
"""Générateur de molécules par IA"""
def __init__(self, model_path: str):
self.model = torch.load(model_path) # VAE ou diffusion
def generate_similar(self, smiles: str, n_samples: int = 10) -> list[str]:
"""Génère des molécules similaires à une molécule donnée"""
# Encoder la molécule source
mol = Chem.MolFromSmiles(smiles)
fingerprint = AllChem.GetMorganFingerprintAsBitVect(mol, 2)
# Générer dans l'espace latent
z = self.model.encode(fingerprint)
molecules = []
for _ in range(n_samples):
# Perturbation dans l'espace latent
z_new = z + torch.randn_like(z) * 0.1
new_smiles = self.model.decode(z_new)
# Valider la molécule
if Chem.MolFromSmiles(new_smiles) is not None:
molecules.append(new_smiles)
return molecules
def optimize_for_property(self, smiles: str, target_property: str):
"""Optimise une molécule pour une propriété"""
# Gradient ascent dans l'espace latent
# vers la propriété désirée
pass
# Évaluation ADMET (Absorption, Distribution, Métabolisme, Excrétion, Toxicité)
def evaluate_admet(smiles: str) -> dict:
"""Évalue les propriétés ADMET d'une molécule"""
mol = Chem.MolFromSmiles(smiles)
return {
"molecular_weight": Descriptors.MolWt(mol),
"logP": Descriptors.MolLogP(mol), # Lipophilicité
"hbd": Descriptors.NumHDonors(mol), # Donneurs H
"hba": Descriptors.NumHAcceptors(mol), # Accepteurs H
"tpsa": Descriptors.TPSA(mol), # Surface polaire
"rotatable_bonds": Descriptors.NumRotatableBonds(mol),
# Règle de Lipinski (drug-likeness)
"lipinski_violations": sum([
Descriptors.MolWt(mol) > 500,
Descriptors.MolLogP(mol) > 5,
Descriptors.NumHDonors(mol) > 5,
Descriptors.NumHAcceptors(mol) > 10,
])
}
# Exemple
aspirin = "CC(=O)OC1=CC=CC=C1C(=O)O"
print(evaluate_admet(aspirin))Modélisation climatique
Émulateurs IA du climat
┌─────────────────────────────────────────────────────────────────┐
│ ÉMULATEURS CLIMATIQUES IA │
├─────────────────────────────────────────────────────────────────┤
│ │
│ PROBLÈME: Simuler le climat sur 100 ans prend des mois │
│ sur les plus gros supercomputers │
│ │
│ SOLUTION: IA qui émule les modèles physiques │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Modèle climatique Émulateur IA │ │
│ │ (CMIP6, etc.) ───► (entraînement) │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ Scénario SSP245 ───► Prédiction en │ │
│ │ (émissions CO2) quelques secondes │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ PROJETS: │
│ - ClimaX (Microsoft): Foundation model pour climat │
│ - NVIDIA Earth-2: Simulation km-scale │
│ - Google Flood Hub: Prévision inondations 7 jours │
│ │
└─────────────────────────────────────────────────────────────────┘Prévision des événements extrêmes
# Exemple: Prédiction de précipitations extrêmes
# Modèle conceptuel basé sur U-Net + attention
import torch
import torch.nn as nn
class ExtremeWeatherPredictor(nn.Module):
"""Prédicteur d'événements météo extrêmes"""
def __init__(self, in_channels=10, out_channels=1):
super().__init__()
# Architecture type U-Net avec attention
self.encoder = nn.Sequential(
nn.Conv2d(in_channels, 64, 3, padding=1),
nn.ReLU(),
nn.Conv2d(64, 128, 3, stride=2, padding=1),
nn.ReLU(),
)
self.attention = nn.MultiheadAttention(128, 8)
self.decoder = nn.Sequential(
nn.ConvTranspose2d(128, 64, 3, stride=2, padding=1, output_padding=1),
nn.ReLU(),
nn.Conv2d(64, out_channels, 3, padding=1),
nn.Sigmoid(), # Probabilité d'événement extrême
)
def forward(self, x):
# x: [batch, channels, lat, lon]
# channels: température, pression, humidité, etc.
encoded = self.encoder(x)
b, c, h, w = encoded.shape
# Self-attention spatiale
flat = encoded.flatten(2).permute(2, 0, 1) # [h*w, batch, c]
attended, _ = self.attention(flat, flat, flat)
attended = attended.permute(1, 2, 0).view(b, c, h, w)
return self.decoder(attended)
# Entraînement sur données historiques d'événements extrêmes
# (ERA5 + bases de données de catastrophes)Autres applications scientifiques
Mathématiques (AlphaGeometry)
┌─────────────────────────────────────────────────────────────────┐
│ ALPHAGEOMETRY │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Résout des problèmes de géométrie niveau Olympiade │
│ │
│ Architecture hybride: │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ┌────────────────┐ ┌────────────────┐ │ │
│ │ │ LLM │◄─────►│ Moteur │ │ │
│ │ │ (intuition) │ │ symbolique │ │ │
│ │ │ │ │ (rigueur) │ │ │
│ │ └────────────────┘ └────────────────┘ │ │
│ │ │ │
│ │ Le LLM propose des constructions auxiliaires │ │
│ │ Le moteur symbolique vérifie et complète la preuve │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ Performance: 25/30 problèmes IMO (médaille d'argent) │
│ │
└─────────────────────────────────────────────────────────────────┘Physique des particules
# IA pour le LHC (CERN)
# Classification des collisions de particules
"""
Au LHC, 1 milliard de collisions/seconde
L'IA filtre en temps réel les événements intéressants
"""
class ParticleClassifier:
"""Classifie les événements du détecteur"""
def __init__(self):
# Graph Neural Network pour données de détecteur
self.model = GraphNeuralNetwork(
node_features=8, # énergie, position, etc.
edge_features=4,
output_classes=5 # types de particules
)
def classify_event(self, hits: list[dict]) -> dict:
"""
Classifie un événement de collision
hits: liste de points détectés
[{"energy": 1.2, "x": 0.1, ...}, ...]
Retourne: probabilités pour chaque type de particule
"""
graph = self.build_graph(hits)
predictions = self.model(graph)
return {
"higgs": predictions[0],
"top_quark": predictions[1],
"w_boson": predictions[2],
"z_boson": predictions[3],
"background": predictions[4],
}Astronomie
┌─────────────────────────────────────────────────────────────────┐
│ IA EN ASTRONOMIE │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 1. DÉTECTION D'EXOPLANÈTES │
│ - Analyse des courbes de lumière (transits) │
│ - 5000+ exoplanètes découvertes │
│ - Kepler, TESS + CNN │
│ │
│ 2. CLASSIFICATION DE GALAXIES │
│ - Galaxy Zoo: classification participative │
│ - Morpheus: classification automatique │
│ - Des millions de galaxies classées │
│ │
│ 3. DÉTECTION D'ONDES GRAVITATIONNELLES │
│ - LIGO/Virgo utilisent des réseaux de neurones │
│ - Filtrage du bruit en temps réel │
│ - Détection de fusions trous noirs/étoiles à neutrons │
│ │
│ 4. SIMULATION COSMOLOGIQUE │
│ - CAMELS: émulateur de l'univers │
│ - 1000x plus rapide que simulations N-corps │
│ │
└─────────────────────────────────────────────────────────────────┘Défis et éthique
┌─────────────────────────────────────────────────────────────────┐
│ DÉFIS DE L'IA SCIENTIFIQUE │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ⚠ REPRODUCTIBILITÉ │
│ - Les modèles IA sont des "boîtes noires" │
│ - Difficile de comprendre pourquoi une prédiction │
│ - Besoin de validation expérimentale │
│ │
│ ⚠ BIAIS DANS LES DONNÉES │
│ - Données historiques biaisées │
│ - Sous-représentation de certaines régions/populations │
│ - Risque de perpétuer les biais existants │
│ │
│ ⚠ HALLUCINATIONS │
│ - L'IA peut prédire des structures protéiques impossibles │
│ - Molécules toxiques ou instables générées │
│ - Validation expérimentale indispensable │
│ │
│ BONNES PRATIQUES: │
│ ✓ Toujours valider expérimentalement │
│ ✓ Documenter les incertitudes │
│ ✓ Publier les modèles et données │
│ ✓ Audit des biais potentiels │
│ │
└─────────────────────────────────────────────────────────────────┘Pour aller plus loin
- AlphaFold Database
- AlphaFold 2 Paper - Jumper et al.
- GraphCast Paper - DeepMind
- ColabFold
- RDKit Documentation
- NVIDIA Earth-2
- ClimaX Paper - Microsoft