9.2 Exponenciális és logaritmikus skála

9.2.1 Cél és konkrét helyzet

A Northstar-rendelések között vizsgáljuk a distance_km szállítási távolságot. A megfigyelési egység egy rendelés, a bemenet a tisztaz orders.csv pozitív kilométer-oszlopa; a cél annak eldöntése, hogy a ferde, jobbra elnyúló eloszlás logaritmikus skálán jobban áttekinthető-e, és mi a teendő nulla vagy negatív értékekkel. A kimenet egy nyers és egy log-skálás hisztogram, valamint egy dokumentált döntés a zéró/negatív kezelésről.

Előzetes becslés: a távolságok tipikusan néhány kilométertől néhány száz kilométerig terjednek, így a nyers hisztogram jobbra ferde lesz, a log10-transzformált pedig közelítőleg szimmetrikusabb, mert $10$-szeres szorzók azonos távolságra kerülnek. Kézzel kiszámolva: ha egy érték $1$, akkor $\log_{10}(1)=0$; ha $10$, akkor $1$; ha $100$, akkor $2$; ha $1000$, akkor $3$. Ez már mutatja, hogy a logaritmus a szorzókat összeadássá alakítja.

9.2.2 Az exponenciális függvény és inverze, a logaritmus

Az exponenciális függvény (exponential function) a természetes alappal:

$$\exp(x) = e^x, \quad\text{ahol } e \approx 2{,}71828.$$

Jelölésmagyarázat: $x$ a bemenet, mértékegység nélküli valós szám; $e^x$ a kimenet, szintén mértékegység nélküli, de mindig szigorúan pozitív. Tömbalakban: ha x egy (n,) alakú NumPy-tömb, akkor az np.exp(x) ugyancsak (n,) alakú, és elemenként számol. A függvény értelmezési tartománya $\mathbb{R}$, értékkészlete $(0, \infty)$.

Három tulajdonság, amit minden későbbi modellépítésben használunk:

1. $\exp(0)=1$,
2. $\exp(a+b)=\exp(a)\cdot\exp(b)$, azaz a szorzás és összeadás közötti híd,
3. $\exp$ szigorúan monoton növekvő, tehát ha $x_1 < x_2$, akkor $\exp(x_1) < \exp(x_2)$.

A logaritmus (logarithm) a hatványozás inverze: ha $b^y = x$, akkor $y = \log_b(x)$. Az $e$ alapú logaritmust természetes logaritmusnak nevezzük, és $\ln(x)$-szel jelöljük. A Python math.log(x) és a NumPy np.log(x) is természetes logaritmust számol; a $10$-es alapú függvény külön math.log10(x) és np.log10(x) hívás.

Az inverz tulajdonság:

$$\ln(\exp(x)) = x \quad\text{minden } x\in\mathbb{R}\text{-re}, \qquad \exp(\ln(x)) = x \quad\text{minden } x>0\text{-ra}.$$

Így $\ln(1)=0$, mert $\exp(0)=1$; $\ln(e)=1$; és általában $\ln(10^k)=k\ln(10)$. A logaritmus értelmezési tartománya csak a pozitív számok halmaza $(0,\infty)$; nullára a bal oldali határ $-\infty$, negatív valós számra pedig nincs valós logaritmus. Ez a legfontosabb korlát a gyakorlatban: mielőtt logaritmálunk, dokumentálnunk kell, hogy az adat csak pozitív, vagy meg kell oldani a nulla/negatív értékek kezelését másképp.

9.2.3 Miért használunk logaritmikus skálát?

A logaritmikus skála a szorzókat additívvá alakítja:

$$\log_b(x_1 \cdot x_2) = \log_b(x_1) + \log_b(x_2).$$

Például az $1, 10, 100, 1000$ sorozat esetén a log10 értékek $0, 1, 2, 3$: az eredetileg exponenciálisan növekvő ugrások azonos lépésközzé vál­­nak. Ezért ha egy pozitív adatsor több nagyságrendet fog át, a log-skálás hisztogram vagy vonaldiagram sűríti a nagy értékeket, és láthatóvá teszi a kis értékek szerkezetét.

A monoton transzformáció (monotonic transformation) olyan függvény, amely megőrzi a sorrendet. Mivel $\ln$ szigorúan növekvő, ha $x_1 < x_2$, akkor $\ln(x_1) < \ln(x_2)$. A sorrend megmarad, de a távolságok nem: például $\lvert \ln(10)-\ln(1)\rvert \approx 2{,}303$, míg $\lvert \ln(100)-\ln(10)\rvert$ is $\approx 2{,}303$ — az eredeti $9$ és $90$ különbség helyett mindkét lépés azonos. Ez előny az ábrázolásban, de fontos következmény: a log-skálán számolt átlag nem az eredeti skála számtani átlaga, erre az alfejezet végén visszatérünk.

A logaritmus a későbbi statisztikai modellezésben is központi szerepet kap. A log-likelihood (logaritmikus likelihood) azért használatos, mert a likelihood sok valószínűség szorzata; az $1$ alatti szorzások gyorsan alulcsordulnak (underflow) a lebegőpontos ábrázolásban, míg a logaritmusok összege stabil marad:

$$\ln\left(\prod_{i=1}^{n} p_i\right) = \sum_{i=1}^{n} \ln(p_i).$$

Itt $p_i \in (0,1]$ az $i$-edik megfigyelés likelihood-tényezője, $\prod$ a szorzatjel, $\sum$ az összegjel; az egyenlet a logaritmus szorzat-összeg azonosságának $n$-tagú kiterjesztése. A cél a numerikus stabilitás: $10^{-300}\cdot 10^{-300}$ a lebegőpontos float64 tartományban már nulla, de $\ln(10^{-300})+\ln(10^{-300})$ körülbelül $-1381{,}6$, kényelmesen ábrázolható. Ezzel a gondolattal a likelihood-alapú becslésnél (Paraméter, becslő és likelihood) találkozunk majd újra; itt elég annyi, hogy a logaritmus a szorzást összeadássá alakítja, ami numerikusan és jelölésben is kezelhetőbb.

A logit előképe (logit preimage) a $(0,1)$ nyílt intervallumot képezi le a teljes $\mathbb{R}$-re:

$$\operatorname{logit}(p) = \ln\left(\frac{p}{1-p}\right) = \ln(p) - \ln(1-p), \quad p \in (0,1).$$

A $p$ itt valószínűség, mértékegység nélküli; a kimenet szintén mértékegység nélküli, negatív vagy pozitív. Az „előkép” kifejezés arra utal, hogy $p$ a $(0,1)$ intervallumból érkezik, a transzformáció eredménye pedig korlátlan valós szám. A határértékek: $p\to 0^+$ esetén $\operatorname{logit}(p)\to-\infty$, $p\to 1^-$ esetén $\operatorname{logit}(p)\to+\infty$, $\operatorname{logit}(0{,}5)=0$. Ennek gyakorlati értelme: ha egy modell valószínűséget becsül, akkor a nyers lineáris prediktor a valós skálán él, és a logit inverze, a logisztikus függvény, szorítja vissza $(0,1)$-be:

$$p = \frac{1}{1+\exp(-\eta)}, \quad\text{ahol } \eta = \operatorname{logit}(p).$$

Ez a későbbi logisztikus regresszió (Lineáris és logisztikus prediktív modellek) magja; most annyi a feladatunk, hogy a logit mint transzformáció kiszámítását és tartományát megértsük.

9.2.4 A log1p és a numerikus stabilitás

Ha az adatsorban nulla érték is előfordul, a $\ln$ nem alkalmazható közvetlenül, mert $\ln(0)$ nem értelmezhető. Az egyik bevett megoldás a $\ln(1+x)$ transzformáció, amit a NumPy a log1p függvénnyel számol:

$$\operatorname{log1p}(x) = \ln(1+x), \quad x > -1.$$

A log1p előnye nem csupán kényelem, hanem numerikus pontosság: amikor $x$ kicsi, például $x=10^{-16}$, az $1+x$ lebegőpontos összeg már kerekítési hibát szenved, így a $\ln(1+x)$ direkt kiszámítása pontatlan. A log1p belsőleg a $\ln(1+x)$ sorfejtését használja, és kis $x$-re pontos eredményt ad. A két kifejezés ugyanazt a matematikai értéket célozza, de a numerikus út különböző.

Szemléltető, kézzel ellenőrizhető értékek:

A log1p tehát a nulla érték kezelésének standard építőköve, amikor a logaritmust közelítő transzformációt akarunk pozitív, de kis értékek mellett is.

9.2.5 Teljes minimális munkapélda

A feladat: generáljunk ferde, jobbra elnyúló pozitív adatsort, rajzoljunk nyers és log-skálás hisztogramot, és dokumentáljuk a nulla/negatív kezelést. A kód a szokásos importokkal kezdődik, a véletlengenerátort rögzítjük, hogy a munkamenet reprodukálható legyen:

import numpy as np
import matplotlib.pyplot as plt

# Rögzített seed: a szimulációs adat ugyanazt a sorrendet adja ugyanazon CPU-verzión
rng = np.random.default_rng(20261020)

# Ferde pozitív adat: lognormális eloszlás, n=5000 megfigyelés.
# A lognormális azt jelenti, hogy a természetes logaritmusa normális eloszlású.
x_positive = rng.lognormal(mean=2.0, sigma=1.1, size=5000)

# Szándékosan hozzáadunk 50 nullát és 30 negatív értéket,
# hogy a kezelést gyakoroljuk. A negatív értékeket -0.5 és -10 között
# egyenletesen sorsoljuk; ezek azt modellezik, hogy hibás vagy csonkolt
# adat érkezett, amire transzformáció előtt dönteni kell.
x_zero = np.zeros(50)
x_negative = rng.uniform(low=-10.0, high=-0.5, size=30)

# A teljes nyers adatsor; a döntéshez külön kezeljük a három csoportot.
x = np.concatenate([x_positive, x_zero, x_negative])

# 1. lépés: csak a pozitív adatra ábrázolunk, mert log(0) és log(negatív)
# valós számokon nem értelmezhető GYIK-ként szerepelő módon.
mask_positive = x > 0
x_pos_only = x[mask_positive]

# 2. lépés: a nulla értékeket log1p-vel kezeljük:
# log1p(0)=0, az eredmény továbbra is pozitív, sorrendtartó.
x_with_zero = x_zero
log1p_zero = np.log1p(x_with_zero)

# 3. lépés: a negatív értékeket külön dokumentáljuk; itt nem transzformáljuk,
# hanem hibajelentésbe gyűjtjük, mert a log1p csak ( -1, inf )-en értelmezhető.
negative_count = int(np.count_nonzero(x < 0))
print(f"Negatív értékek száma (kihagyva a log-transzformációból): {negative_count}")

# 4. lépés: ábrázolás. A pozitív adatra nyers és log10 skálájú hisztogram.
fig, axes = plt.subplots(1, 2, figsize=(10, 4))
axes[0].hist(x_pos_only, bins=60, color="steelblue", edgecolor="white", alpha=0.85)
axes[0].set_title("Nyers távolság eloszlás")
axes[0].set_xlabel("km")
axes[0].set_ylabel("Rendelések száma")

axes[1].hist(np.log10(x_pos_only), bins=60, color="darkorange", edgecolor="white", alpha=0.85)
axes[1].set_title("Log10-transzformált távolság")
axes[1].set_xlabel("log10(km)")
axes[1].set_ylabel("Rendelések száma")
plt.tight_layout()
plt.show()

A fenti kód még nem automatizáltan ellenőrzött, így a kimenetet szemléltető jellegűnek nevezzük. A várt viselkedés: a bal oldali hisztogram jobbra elnyúló, tömeg a kis értékeknél; a jobb oldali ábra közelítőleg szimmetrikus haranggörbe, mert a lognormális definíció szerint éppen ezt várjuk. A np.log10 negatív vagy nulla bemenetre RuntimeWarning-ot ad és -inf-et vagy nan-t szolgáltat, ezért a mask szükséges. A negative_count a példánkban $30$.

Kézi kontroll a logaritmusazonosságra, amit a kód ellenőrzéséhez papíron is kiszámolunk:

# Egyszerű ellenőrző vektor
x_check = np.array([1.0, 10.0, 100.0, 1000.0])
log10_check = np.log10(x_check)
# Elvárt: [0., 1., 2., 3.]

# A log1p és log(1+x) ekvivalenciája pozitív x-re:
y = np.array([0.0, 0.5, 1.0, 10.0])
diff = np.log1p(y) - np.log(1.0 + y)
# Elvárt: diff minden eleme 0 vagy 1e-16 nagyságrendű kerekítési hiba

Az ellenőrzési feltétel a shape-re: x_check shape-je (4,), a log10_check shape-je szintén (4,), a dtype float64. Toleranciánk a kézi kontrollnál szigorú, de a lebegőpontos művelet miatt $\le 10^{-15}$ eltérést fogadunk el.

9.2.6 Eredmény értelmezése

A lognormális eloszlás definíciója szerint a $\ln(x)$ normális, ezért a $\log_{10}$ transzformált hisztogram vártan szimmetrikus. Ez nem azt jelenti, hogy a nyers adat hibás; csak azt, hogy a skálaváltás megmutatja a mögöttes multiplikatív struktúrát. A nulla értékeket log1p-vel $0$-ba képeztük le, ami megőrzi a nullák megkülönböztetését; ha egy nullát és egy kis pozitív értéket szeretnénk összehasonlítani, a log1p az eredeti sorrendet megtartja. A negatív értékeket kihagytuk, mert a valós logaritmus tartománya $(0, \infty)$; ez a döntés a munkanaplóba írandó, mert később a negatív távolság adatminőségi hibát jelezhet.

Kiemelt ellenőrzési pont: a transzformált tömb dtype-ja float64, mert az egész értékek logaritmusa is általában irracionális lebegőpontos szám. A np.log10(1000) pontosan $3{,}0$, de a np.log10(10) belső ábrázolása kerekítési hibát tartalmazhat; ezért a fenti kontrollt np.allclose-zal érdemes futtatni, atol=1e-15 mellett.

A log-skálán vett átlag értelmezése külön figyelmet érdemel. Ha $x_1, x_2, \dots, x_n$ pozitív megfigyelések, akkor az exp-transzformált log-átlag a geometriai átlag (geometric mean):

$$GM = \exp\left(\frac{1}{n}\sum_{i=1}^{n}\ln(x_i)\right).$$

Ez nem a szokásos számtani átlag. Például $x = [1, 10, 100]$ esetén a számtani átlag $37$, a geometriai átlag

$$\exp\left(\frac{\ln(1)+\ln(10)+\ln(100)}{3}\right) = \exp\left(\frac{0+2{,}3026+4{,}6052}{3}\right) = \exp(2{,}3026) = 10.$$

Itt $\ln(x_i)$ mértékegység nélküli; a képletben $x_i > 0$ minden $i$-re, és a tömb alakja (n,). A geometriai átlag a multiplikatív folyamatok „középértéke”: ha egy folyamat minden lépésben valahányszorosára nő, akkor az átlagos szorzó ennyi. A futási példánkban a lognormális eloszlású távolságok esetén a geometriai átlag rendre kisebb, mint a számtani, mert a nagy ritka értékek a számtani átlagot jobban felfelé húzzák.

9.2.7 Feladatok

1. feladat — Értelmezés. Magyarázd el, miért nincs értelmezve $\log_{10}(0)$ és $\log_{10}(-5)$, és add meg a következő értékeket négy tizedesjegyre: $\log_{10}(0{,}001)$, $\log_{10}(1)$, $\log_{10}(10)$, $\log_{10}(10^5)$.

2. feladat — Megvalósítás. Írj Python-függvényt log_shifted(x, c) néven, amely a log1p függvénnyel kiszámolja a $\ln(c + x)$ értéket, feltéve, hogy $c + x > 0$ minden elemre. A függvény ellenőrizze, hogy a bemeneti tömb minden eleme kielégíti-e a feltételt, és ha nem, ValueError-t dobjon. Próbáld ki a [-0.5, 0.0, 1.0, 10.0] bemenetre $c=1$ mellett, és ellenőrizd kézzel: az eredmény [ln(0.5), 0, ln(2), ln(11)].

3. feladat — Hibadiagnózis. Egy munkatárs a havi kosárértékeket akarta elemezni, és a következőt írta: „Kiszámítom a log-értékek átlagát, majd visszaexponálom, az lesz a havi átlagos kosár.” Miért helytelen ez a megfogalmazás? Adj konkrét ellenpéldát két pozitív számmal, ahol a számtani átlag és az exp-átlagos-log érték különbözik, és nevezd meg a helyes kifejezést a kapott értékre.

4. feladat — Megváltozott feltételű továbbvitel. Az adatsorba negatív értékek is kerülnek, például nettó profit, amely lehet negatív. Dolgozz ki transzformációs konvenciót: adj képletet, amely negatív $x$-re is definiált, megőrzi a sorrendet, és $0$-ban folytonos. Képlet:

$$y = \begin{cases} \ln(1+x), & x \ge 0,\\ -\ln(1-x), & x < 0. \end{cases}$$

Ezt gyakran signed_log-nak nevezik. Implementáld NumPy-ban, és ellenőrizd a következő értékeken: $x = [-10, -1, 0, 1, 10]$; add meg a várt eredményt négy tizedesjegyre.

9.2.8 Megoldások és indoklás

1. megoldás. A logaritmus a hatványozás inverze: $\log_b(x)=y$ pontosan akkor, ha $b^y=x$. A $10$-es alapú hatvány bármely valós kitevőre pozitív, tehát $10^y$ soha nem $0$ és soha nem negatív; így az egyenletnek nincs megoldása $x=0$-ra vagy $x<0$-ra. Az értékek: $\log_{10}(0{,}001)=\log_{10}(10^{-3})=-3$; $\log_{10}(1)=0$; $\log_{10}(10)=1$; $\log_{10}(10^5)=5$. Ellenőrzés: $10^{-3}=0{,}001$, $10^0=1$, $10^1=10$, $10^5=100000$; mind a négy számítás az inverz definícióból következik, tolerancia nélkül pontos, mert a kitevők egészek.

2. megoldás. A függvény:

import numpy as np

def log_shifted(x, c):
    x = np.asarray(x, dtype=float)
    if np.any(x + c <= 0):
        raise ValueError("A logaritmus argumentuma minden elemre pozitív kell legyen.")
    return np.log1p(x + c - 1.0)

A log1p(z) definíciója $\ln(1+z)$, ezért $\ln(c+x) = \ln(1 + (x+c-1))$, tehát a log1p(x + c - 1.0) hívás pontos eredményt ad. A megadott bemenetre $c=1$ mellett a kimenet $[\ln(0{,}5), \ln(1), \ln(2), \ln(11)] \approx [-0{,}6931, 0, 0{,}6931, 2{,}3979]$. Ellenőrzés: $\ln(0{,}5) = -\ln(2) \approx -0{,}6931$; a többi érték a természetes logaritmus táblázatából adódik. A shape (4,), a dtype float64.

3. megoldás. Az $\exp(\text{átlag}(\ln x))$ a geometriai átlag, nem a számtani. Konkrét ellenpélda: $x=[1, 100]$ esetén a számtani átlag $(1+100)/2 = 50{,}5$; a log-átlag $(\ln 1 + \ln 100)/2 = (0+4{,}6052)/2 = 2{,}3026$; visszaexponálva $\exp(2{,}3026) = 10$. A két eredmény különbözik, mert a logaritmus nem lineáris transzformáció, ezért az átlag nem vihető át rajta. A munkatársnak vagy geometriai átlagnak kell neveznie az eredményt, és azt a szorzóközpontú folyamatokra használni, vagy a havi átlagos kosárértékhez a nyers skálán kell számtani átlagot számolnia. A tanulság: a log-skála sorrendtartó, de a távolságokat torzítja, így a statisztikai összegzők is megváltoznak.

4. megoldás. A signed_log implementáció:

import numpy as np

def signed_log(x):
    x = np.asarray(x, dtype=float)
    result = np.zeros_like(x)
    pos = x >= 0
    neg = x < 0
    result[pos] = np.log1p(x[pos])
    result[neg] = -np.log1p(-x[neg])
    return result

A várt értékek négy tizedesjegyre:

A transzformáció szimmetrikus: $\text{signed\_log}(-x) = -\text{signed\_log}(x)$, sorrendtartó, és $0$-ban folytonos. A log1p használata a $0$ körüli stabilitást is biztosítja. Ez a konvenció megőrzi a negatív értékek előjelét, és csak akkor alkalmazható, ha az elemek nagyobbak $-1$-nél a pozitív oldalon és hasonlóan a negatív oldalon; általános $x$-re a $c$-eltolásos változat is építhető, de akkor a választott $c$-t a munkanaplóban dokumentálni kell.

9.2.9 Gyakori tévedés ellenpéldával

A leggyakoribb hiba: a logaritmikus skálán vett átlagot egyszerűen exponáljuk, és azt gondoljuk, hogy az eredeti skála átlagát kapjuk vissza. Az előző ellenpélda is ezt mutatja: $x=[1,100]$ esetén az eredeti számtani átlag $50{,}5$, a log-úton kapott $10$. A hiba forrása, hogy a logaritmus nem lineáris, ezért az átlag és a transzformáció sorrendje nem felcserélhető: $\overline{\ln(x)} \ne \ln(\bar{x})$. A helyes kapcsolat a Jensen-egyenlőtlenség következménye, amely szerint a konkáv $\ln$ függvényre $\overline{\ln(x)} \le \ln(\bar{x})$, pozitív szórású adatnál szigorú egyenlőtlenséggel. A gyakorlatban tehát mindig dönteni kell: ha az eredeti fizikai skála számtani átlaga a cél, akkor a log-skálán számolt modellből való visszatérés nem elegendő; a modell pontosítása és a predikció vissza-transzformációja külön lépést igényel (a későbbi fejezetekben a lognormális modellnél látjuk majd a korrekciót). Ez a tévedés szorosan kapcsolódik a Jelölésből végrehajtható számítás alfejezetben tárgyalt jelölési disciplínához: a formula megmondja a sorrendet, csak követni kell.

A pozitív adatok logaritmizálása a skálát változtatja meg, de nem teszi automatikusan normálissá az eloszlást. A log1p(x) a log(x)-tól különböző transzformáció, amely a nulla értéket is kezeli; az eredményt ennek megfelelően kell értelmezni.

9.2.10 Rövid összefoglaló

Az exponenciális függvény és a logaritmus egymás inverze; a logaritmus a szorzást összeadássá, a szorzókülönbségeket azonos lépésekké alakítja. A természetes logaritmus csak pozitív számokra értelmezhető, ezért nulla értéknél a log1p, negatív értéknél pedig vagy kihagyás, vagy signed_log szükséges. A logit a $(0,1)$ valószínűségi skálát képezi a valós egyenesre, előkészítve a logisztikus modellezést. A log-skálán számolt átlag a geometriai átlag, nem a számtani; ennek fel nem ismerése tipikus hibás értelmezés. A következő alfejezetben a határértéket mint közelítési folyamatot vizsgáljuk meg, ami a numerikus közelítés és a derivált alapfogalma lesz.