Språkmodeller för kod

Kodmodeller tränas på kod plus text, men med två skillnader mot vanliga språkmodeller:

1. Fill-in-the-middle (FIM). En vanlig autoregressiv modell kan bara fortsätta framåt. Men i en editor står markören mitt i en fil — det finns kod både före och efter. FIM-träning omarrangerar exempel till <prefix> <suffix> <middle> så att modellen lär sig fylla i luckor med kännedom om båda hållen.

2. Exekverbar utvärdering. Kod har ett facit som går att köra. pass@k mäter sannolikheten att minst ett av k genererade förslag passerar testerna — ett mycket hårdare och ärligare mått än textlikhet.

pass@k skattas obiased ur n genererade lösningar varav c passerar (Chen m.fl. 2021): $\text{pass@}k = \mathbb E\left[1 - \frac{\binom{n-c}{k}}{\binom{n}{k}}\right]$ Generera n = 20, räkna c, beräkna för k = 1, 5, 10. Att generera k gånger och ta andelen som lyckades är biased och överskattar.

Benchmarks och deras status: HumanEval (164 uppgifter, mättad och kontaminerad), MBPP, SWE-bench (riktiga GitHub-issues, mycket svårare), LiveCodeBench (roterande uppgifter publicerade efter modellernas cutoff — det bästa skyddet mot kontaminering).

Risker som är specifika för genererad kod:

• Säkerhetshål: modeller reproducerar osäkra mönster som är vanliga i träningsdatan (SQL-injektion, hårdkodade hemligheter). Pearce m.fl. (2021) fann att ~40 % av genererad kod i säkerhetskänsliga scenarier innehöll sårbarheter.
• Hallucinerade beroenden: modellen importerar paket som inte finns — vilket öppnar för «slopsquatting», där någon registrerar just det paketnamnet.
• Licenskontamination: kod som ordagrant reproducerar copyleft-licensierad träningsdata.
• Tyst felaktighet: koden kör och ser rimlig ut men gör fel sak. Testerna är ditt enda skydd.

Därför är regeln enkel: granska och testa genererad kod som om den kom från en okänd bidragsgivare — för det gör den.

import itertools, numpy as np

def pass_at_k(n: int, c: int, k: int) -> float:
    """Obiased skattning. n genererade, c korrekta."""
    if n - c < k:
        return 1.0
    return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1, n + 1))

for c in (0, 1, 5, 20):
    print(c, [round(pass_at_k(20, c, k), 3) for k in (1, 5, 10)])
# 0  [0.0, 0.0, 0.0]
# 1  [0.05, 0.25, 0.5]
# 5  [0.25, 0.806, 0.984]
# 20 [1.0, 1.0, 1.0]

# FIM-formatet (StarCoder/CodeLlama-stil)
PROMPT = "<fim_prefix>{prefix}<fim_suffix>{suffix}<fim_middle>"

# Kör alltid genererad kod i sandlåda — aldrig i processen som genererade den.

AI-grafens egna kodövningar och labbar bygger på exakt denna princip: genererad eller inlämnad kod körs i en isolerad container utan nät, och bedöms av tester — inte av hur koden ser ut.