Exponentialfunktioner

Linjärt: du lägger till lika mycket varje gång. 100, 110, 120, 130 …

Exponentiellt: du multiplicerar med lika mycket varje gång. 100, 110, 121, 133,1 …

Skillnaden verkar liten i början och blir sedan gigantisk.

Steg	Linjärt (+10)	Exponentiellt (×1,1)
0	100	100
10	200	259
50	600	11 739
100	1 100	1 378 061

Formen är $f(x) = a \cdot b^x$ där $b$ är tillväxtfaktorn:

$b$	Vad som händer
$b > 1$	växer
$b = 1$	står still
$0 < b < 1$	avtar mot noll, men når den aldrig

Talet $e \approx 2{,}718$ är det val av bas som gör derivatan enklast möjlig: $\frac{d}{dx}e^x = e^x$. Funktionen är sin egen derivata. Det är därför $e$ dyker upp överallt i matematiken bakom ML.

Halveringstid och fördubblingstid. Om något avtar med faktorn $b$ per steg:

$\text{halveringstid} = \frac{\ln 0{,}5}{\ln b}$

För tillväxt används samma formel med $\ln 2$. Tumregeln «72-regeln» är en approximation av just detta: vid $p$ procents tillväxt per period är fördubblingstiden ungefär $72/p$ perioder.

Var exponentialfunktioner dyker upp i ML:

Sammanhang	Uttryck	Varför
Lärhastighetsschema	$\eta_t = \eta_0 \cdot \gamma^t$	stora steg först, små sedan
Glidande medelvärde (Adam)	$m_t = \beta m_{t-1} + (1-\beta)g_t$	gamla gradienter tappar vikt exponentiellt
Softmax	$e^{z_i} / \sum_j e^{z_j}$	gör tal till sannolikheter, förstärker skillnader
Diskontering i RL	$\gamma^t$	framtida belöningar väger mindre
Glömskekurvan	$e^{-t/\tau}$	kunskap bleknar utan repetition

Den sista raden är AI-grafens egen: plattformens mastery-modell låter behärskningen avta exponentiellt med tiden, med en tidskonstant $\tau$ som växer varje gång du repeterar. Det är därför andra repetitionen håller längre än den första.

Numerisk fälla. $e^{1000}$ svämmar över i flyttal. Därför räknar man med logaritmer i stället — och därför normaliserar softmax alltid genom att dra bort det största värdet först:

$\frac{e^{z_i}}{\sum_j e^{z_j}} = \frac{e^{z_i - \max z}}{\sum_j e^{z_j - \max z}}$

Samma svar, men inga överflöden. Det är ett av de vanligaste numeriska knepen i hela fältet.

import math

# Linjärt mot exponentiellt
for steg in (0, 10, 50, 100):
    print(f"{steg:4d}  linjärt {100 + 10 * steg:>10,}   exp {100 * 1.1 ** steg:>15,.0f}")

# e är sin egen derivata — kontrollera numeriskt
h = 1e-7
for x in (0.0, 1.0, 2.0):
    derivata = (math.exp(x + h) - math.exp(x)) / h
    print(f"x={x}  f(x)={math.exp(x):.5f}  f'(x)≈{derivata:.5f}")

# Halveringstid vid 5 % minskning per steg
b = 0.95
print(round(math.log(0.5) / math.log(b), 1), "steg")     # 13.5 steg

# Lärhastighetsschema
eta0, gamma = 0.1, 0.95
for epok in (0, 10, 50, 100):
    print(f"epok {epok:3d}: lr = {eta0 * gamma ** epok:.6f}")

# Numerisk fälla — och lösningen
z = [1000.0, 1001.0, 1002.0]
try:
    naiv = [math.exp(v) for v in z]
except OverflowError as e:
    print("naiv softmax:", e)                 # math range error

m = max(z)
exp_stabil = [math.exp(v - m) for v in z]
s = sum(exp_stabil)
print([round(v / s, 4) for v in exp_stabil])   # [0.0900, 0.2447, 0.6652]

De sista raderna visar knepet i sin renaste form: att dra bort maxvärdet ändrar inte svaret (faktorn förkortas bort) men tar bort överflödet helt.