AI i naturvetenskap: från proteiner till klimat

Maskininlärning har blivit ett standardverktyg i naturvetenskapen. Några områden där det gjort verklig skillnad:

Det som gör dessa tillämpningar speciella är att det finns en underliggande teori. Till skillnad från att förutsäga vilken reklam någon klickar på finns fysikaliska lagar som måste gälla — och det går både att utnyttja och att kontrollera mot.

Fyra metodfrågor som är svårare inom naturvetenskap än i vanlig ML:

1. Uppdelningen måste spegla den vetenskapliga frågan. En slumpmässig uppdelning av molekyler ger nästan alltid för optimistiska resultat, eftersom snarlika molekyler hamnar i både träning och test. Rätt uppdelning beror på frågan:

2. Fysikaliska begränsningar bör byggas in. En modell som förutsäger energi ska respektera bevarandelagar och symmetrier. Ekvivarianta nätverk — som ger samma svar oavsett hur molekylen roteras — behöver inte lära sig symmetrin från data och blir dramatiskt mer dataeffektiva.

3. Osäkerhet är inte valfri. En förutsägelse utan felstapel är inte ett vetenskapligt resultat. Ensembler, bayesianska metoder eller konform prediktion ger intervall — och det är intervallet som avgör om experimentet är värt att köra.

4. Reproducerbarhet under granskning. Kod, data, frön, miljö och exakt uppdelning måste publiceras. Fältet har en väldokumenterad reproducerbarhetskris: Kapoor och Narayanan (2023) granskade tillämpningar av ML i sjutton vetenskapliga områden och fann läckage i samtliga — oftast i form av felaktig uppdelning eller att testdata påverkat förbehandlingen.

Frågor att ställa till varje ML-i-vetenskap-påstående:

Den fjärde är den avgörande. AlphaFold blev ett genombrott inte för att den vann en tävling utan för att strukturerna höll när de jämfördes med experimentellt bestämda. En modell som förutsäger en läkemedelskandidat har producerat en hypotes, inte ett läkemedel.

import numpy as np

# 1. Skaffold split: dela på strukturell kärna, inte slumpmässigt
def skaffold_split(molekyler, andel_train=0.8, fro=0):
    """Molekyler med samma kärnstruktur hamnar i SAMMA mängd."""
    from collections import defaultdict
    grupper = defaultdict(list)
    for i, m in enumerate(molekyler):
        grupper[murcko_skaffold(m)].append(i)          # strukturell kärna
    ordnade = sorted(grupper.values(), key=len, reverse=True)
    train, test = [], []
    for g in ordnade:
        (train if len(train) < andel_train * len(molekyler) else test).extend(g)
    return train, test

def jamfor_uppdelningar(X, y, molekyler, modell):
    from sklearn.model_selection import train_test_split
    tr, te = train_test_split(range(len(X)), test_size=0.2, random_state=0)
    slump = modell().fit(X[tr], y[tr]).score(X[te], y[te])
    tr2, te2 = skaffold_split(molekyler)
    skaffold = modell().fit(X[tr2], y[tr2]).score(X[te2], y[te2])
    return {"slumpmassig": round(slump, 3), "skaffold": round(skaffold, 3),
            "optimism": round(slump - skaffold, 3)}
# {'slumpmassig': 0.89, 'skaffold': 0.62, 'optimism': 0.27}
#  ↑ den slumpmässiga siffran är den som brukar rapporteras

# 2. Osäkerhet: ensemble ger både prediktion och intervall
def ensemble_prediktion(modeller, X):
    P = np.stack([m.predict(X) for m in modeller])
    return {"medel": P.mean(0), "std": P.std(0),
            "intervall_95": (P.mean(0) - 1.96 * P.std(0), P.mean(0) + 1.96 * P.std(0))}

# Konform prediktion: intervall med garanterad täckning
def konform_intervall(modell, X_kal, y_kal, X_ny, alfa=0.1):
    residualer = np.abs(y_kal - modell.predict(X_kal))
    n = len(residualer)
    q = np.quantile(residualer, np.ceil((n + 1) * (1 - alfa)) / n, method="higher")
    p = modell.predict(X_ny)
    return p - q, p + q            # täcker sanningen med minst 1 − alfa sannolikhet

# 3. Kontrollera mot fysiken — en modell som bryter mot bevarandelagar är fel
def fysikkontroll(modell, konfigurationer, tolerans=1e-3):
    brott = []
    for k in konfigurationer:
        # rotationsinvarians: samma energi oavsett orientering
        e1 = modell.energi(k)
        e2 = modell.energi(rotera(k, vinkel=np.pi / 3))
        if abs(e1 - e2) > tolerans:
            brott.append({"typ": "rotationsinvarians", "diff": float(abs(e1 - e2))})
        # translationsinvarians
        e3 = modell.energi(translatera(k, [1.0, 0, 0]))
        if abs(e1 - e3) > tolerans:
            brott.append({"typ": "translationsinvarians", "diff": float(abs(e1 - e3))})
    return {"antal_brott": len(brott), "av": 2 * len(konfigurationer), "exempel": brott[:3]}

# 4. Reproducerbarhetsmanifest
def manifest(kod_commit, data_hash, uppdelning, fro, miljo, baslinje_resultat):
    return {"git_commit": kod_commit, "data_hash": data_hash,
            "uppdelningsmetod": uppdelning, "uppdelningsfro": fro,
            "miljo": miljo, "baslinje": baslinje_resultat,
            "kommentar": "uppdelningsmetoden är den enskilt viktigaste raden här"}