Eksponentielt vektet glidende gjennomsnitt
Bruk eksponentiell utjevning for å gi nyere verdier større vekt med ewm(span=), en standardteknikk i finansanalyse.
Eksponentielt vektet glidende gjennomsnitt er en gratis leksjon i Pandas & NumPy Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Pandas & NumPy Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.
Problemet med enkle glidende gjennomsnitt
Et enkelt glidende gjennomsnitt behandler alle n observasjoner i vinduet likt – en pris fra 30 dager siden bidrar like mye som gårsdagens pris. Når De skal forutsi verdier på kort sikt, er imidlertid nyere observasjoner mer informative enn gamle. Et eksponentielt vektet glidende gjennomsnitt (EWMA) løser dette ved å tildele eksponentielt avtakende vekter til eldre observasjoner: gårsdagen teller mest, dagen før teller litt mindre, og slik fortsetter det tilbake til begynnelsen av serien.
import pandas as pd
import numpy as np
np.random.seed(42)
prices = pd.Series(
100 + np.cumsum(np.random.normal(0.5, 2, 30)),
index=pd.date_range('2024-01-01', periods=30)
)
df = pd.DataFrame({'price': prices})
df['SMA_7'] = df['price'].rolling(7).mean()
df['EWM_span7'] = df['price'].ewm(span=7).mean()
print(df.tail(5).round(2))Slik fungerer EWMA-vekting
EWMA beregner hver verdi som en vektet kombinasjon av den gjeldende observasjonen og den forrige EWMA-en: EWM_t = alpha * x_t + (1 - alpha) * EWM_{t-1}. Alpha (utglattingsfaktoren) bestemmer hvor raskt vektene avtar – en stor alpha (nær 1) reagerer raskt på nylige endringer (mindre utglatting), mens en liten alpha (nær 0) reagerer langsomt (mer utglatting). Vektene danner en geometrisk rekke: den nyeste verdien har vekten alpha, den forrige har alpha*(1-alpha), og så videre.
import numpy as np
# Manually show EWMA weights
alpha = 0.3
n_points = 8
weights = [alpha * (1 - alpha)**i for i in range(n_points)]
print(f'Alpha = {alpha}')
print(f'Weights (most recent first):')
for i, w in enumerate(weights):
print(f' t-{i}: {w:.4f}')
print(f'Sum of shown weights: {sum(weights):.4f} (converges to 1.0)')Metoden ewm() og parameteren span
Pandas implementerer EWMA gjennom Series.ewm(). Den mest intuitive parameteren er span, som tilsvarer vinduet i et enkelt glidende gjennomsnitt: alpha = 2 / (span + 1). En span på 10 tilsvarer omtrent et SMA over 10 perioder, men med eksponentielt avtakende vekter i stedet for like vekter. Bruk ewm(span=n).mean() for å få EWMA, og ewm(span=n).std() for eksponentielt vektet volatilitet.
import pandas as pd
import numpy as np
np.random.seed(0)
data = pd.Series(
np.random.normal(100, 10, 50),
index=pd.date_range('2024-01-01', periods=50)
)
df = pd.DataFrame({'value': data})
df['EWM_3'] = df['value'].ewm(span=3).mean()
df['EWM_10'] = df['value'].ewm(span=10).mean()
df['EWM_20'] = df['value'].ewm(span=20).mean()
print('Alpha values:')
for span in [3, 10, 20]:
alpha = 2 / (span + 1)
print(f' span={span} → alpha={alpha:.3f}')
print(df.tail(5).round(2))Parameteren halflife
Parameteren halflife angir hvor mange perioder det tar før vekten reduseres til det halve. Hvis halflife=5, har en verdi fra 5 perioder tilbake halvparten så stor vekt som den gjeldende verdien. Sammenhengen er: alpha = 1 - exp(log(0.5) / halflife). Halflife er ofte mer intuitivt enn span eller alpha fordi den uttrykker gjennomsnittets «hukommelse» direkte i forretningstermer – for eksempel «priser fra 2 uker siden bør ha halvparten så stor innflytelse som dagens pris».
import pandas as pd
import numpy as np
np.random.seed(5)
prices = pd.Series(
100 + np.cumsum(np.random.normal(0, 2, 30)),
index=pd.date_range('2024-01-01', periods=30)
)
df = pd.DataFrame({'price': prices})
# halflife=5: weight halves every 5 days
df['EWM_hl5'] = df['price'].ewm(halflife=5).mean()
# halflife=14: weight halves every 14 days (longer memory)
df['EWM_hl14'] = df['price'].ewm(halflife=14).mean()
print(df.tail(5).round(2))Parameteren alpha direkte
De kan også angi utglattingsfaktoren direkte med ewm(alpha=). Alpha må være mellom 0 og 1 (eksklusiv). En høy alpha, som 0.8, gir svært lite utglatting – EWMA følger det rå signalet tett. En lav alpha, som 0.1, gir kraftig utglatting – EWMA endrer seg langsomt og ligger etter ved plutselige skift. Valget av riktig alpha avhenger av avveiningen mellom reaksjonsevne (å oppdage reelle trendendringer raskt) og stabilitet (å ignorere tilfeldig støy).
import pandas as pd
import numpy as np
np.random.seed(3)
data = pd.Series(
[100]*20 + [120]*20, # sudden level shift at row 20
dtype=float
) + np.random.normal(0, 2, 40)
df = pd.DataFrame({'signal': data})
df['alpha_0.1'] = df['signal'].ewm(alpha=0.1).mean() # slow
df['alpha_0.5'] = df['signal'].ewm(alpha=0.5).mean() # medium
df['alpha_0.9'] = df['signal'].ewm(alpha=0.9).mean() # fast
print('After the level shift (rows 20-25):')
print(df.iloc[18:26].round(2))EWMA for volatilitet: ewm().std()
ewm(span=).std() beregner et eksponentielt vektet standardavvik. Dette danner grunnlaget for EWMA-volatilitetsmodellen som brukes i finansiell risikostyring (også kjent som RiskMetrics-modellen med avtakingsfaktoren lambda=0.94). Eksponentielt vektet volatilitet reagerer raskere på topper i volatiliteten enn et enkelt rullende std, fordi nyere observasjoner med høy varians får større vekt.
import pandas as pd
import numpy as np
np.random.seed(42)
# Simulate returns: quiet period then volatile period
returns = pd.Series(
np.concatenate([
np.random.normal(0, 0.01, 60),
np.random.normal(0, 0.04, 60) # 4x more volatile
]),
index=pd.date_range('2024-01-01', periods=120)
)
df = pd.DataFrame({'returns': returns})
df['rolling_vol'] = df['returns'].rolling(20).std()
df['ewm_vol'] = df['returns'].ewm(span=20).std()
print('Volatility comparison (transition at row 60):')
print(df.iloc[58:65].round(5))MACD: kombinere to EWMA-er
MACD (Moving Average Convergence Divergence) er en klassisk finansiell indikator som bygger på to EWMA-er. Den er forskjellen mellom en rask EWMA (med kort span) og en langsom EWMA (med lang span) av prisen. Når MACD krysser null nedenfra, signaliserer det mulig oppadgående momentum (et kjøpssignal); når den krysser ovenfra, signaliserer det nedadgående momentum. MACD er et godt eksempel på hvordan to EWMA-er kan brukes til å utlede en indikator.
import pandas as pd
import numpy as np
np.random.seed(7)
prices = pd.Series(
100 + np.cumsum(np.random.normal(0.3, 2, 100)),
index=pd.date_range('2024-01-01', periods=100)
)
df = pd.DataFrame({'price': prices})
df['EMA_12'] = df['price'].ewm(span=12).mean() # fast
df['EMA_26'] = df['price'].ewm(span=26).mean() # slow
df['MACD'] = df['EMA_12'] - df['EMA_26']
df['Signal'] = df['MACD'].ewm(span=9).mean() # signal line
print('MACD values (last 8 rows):')
print(df[['price', 'MACD', 'Signal']].tail(8).round(2))EWMA med tidsbasert halflife
Pandas 1.1+ støtter angivelse av halflife, span og com som tidsforskyvninger (for eksempel halflife='7D') når De arbeider med en DatetimeIndex. Dette gjør det mulig å bruke EWMA riktig på tidsserier med ujevne tidsintervaller – hvis De for eksempel har timesdata med opphold i helgene, betyr en halflife på '7D' at vekten faktisk halveres hver 7. kalenderdag, uavhengig av antallet rader i perioden.
import pandas as pd
import numpy as np
np.random.seed(0)
# Business-day data (no weekends)
biz_dates = pd.bdate_range('2024-01-01', periods=20)
prices = pd.Series(100 + np.cumsum(np.random.randn(20)), index=biz_dates)
# halflife as a time offset (7 calendar days)
ewm_7d = prices.ewm(halflife='7D', times=biz_dates).mean()
# halflife as row count (7 rows)
ewm_7rows = prices.ewm(halflife=7).mean()
df = pd.DataFrame({'price': prices, 'hl_7D': ewm_7d, 'hl_7rows': ewm_7rows})
print(df.round(2))Valg mellom EWMA, rolling og expanding
Oppsummering av når De bør bruke de ulike alternativene:
- Rolling(n).mean(): alle de n nyeste observasjonene har lik vekt – egner seg godt for enkle etterfølgende målinger og når alle de nylige periodene er like viktige.
- ewm(span=n).mean(): eksponentielt vektet – best når De ønsker utglatting som reagerer sterkere på nylige endringer, og brukes ofte innen finans og signalbehandling.
- expanding().mean(): alle historiske data har lik vekt – best for YTD- eller statistikk for hele perioden, der det ikke er akseptabelt å glemme gamle data.
Visualisering av EWMA kontra SMA
Å plotte EWMA og SMA sammen i et tidsseriediagram gjør forskjellen i hvor raskt de reagerer, synlig. EWMA reagerer raskere på plutselige nivåendringer fordi den ikke har «glemt» alle tidligere observasjoner – EWMA med kort spenn snur raskere enn en SMA med samme nominelle vindu. Derfor er EWMA et bedre valg i prognoseapplikasjoner der det er viktigere å fange opp trendretningen raskt enn å oppnå maksimal støyreduksjon.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(42)
prices = pd.Series(
np.concatenate([
100 + np.cumsum(np.random.normal(0.3, 1.5, 50)),
130 + np.cumsum(np.random.normal(-0.3, 1.5, 50))
]),
index=pd.date_range('2024-01-01', periods=100)
)
df = pd.DataFrame({'price': prices})
df['SMA_10'] = df['price'].rolling(10).mean()
df['EWMA_10'] = df['price'].ewm(span=10).mean()
df.plot(figsize=(12, 5), title='SMA vs EWMA — EWMA reacts faster to trend reversals')
plt.ylabel('Price')
plt.axvline(x=df.index[50], color='red', linestyle='--', label='Trend change')
plt.legend()
plt.show()EWMA i forretningsapplikasjoner
Utover finans brukes EWMA mye innen produktanalyse og drift: utjevning av kundens livstidsverdi (nylig atferd forutsier fremtidig forbruk bedre enn gammel atferd), overvåking av serverforsinkelse (en eksponentielt utjevnet forsinkelsesmåling utløser færre falske alarmer enn et rullerende gjennomsnitt) og prognoser for lageretterspørsel (de siste salgsukene bør veie tyngre enn data fra seks måneder tilbake). Det universelle prinsippet er: Overalt der aktualitet er viktig, gir EWMA bedre resultater enn enkel gjennomsnittsberegning.
Kort kontroll
Test forståelsen Deres av eksponentielt vektede glidende gjennomsnitt fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen lærte De at ewm(span=) bruker eksponentielt avtagende vekter, slik at nyere observasjoner får større betydning, at alpha styrer hvor raskt metoden reagerer (høy = rask, lav = jevn), og at parameteren halflife uttrykker minnet i termer som har en meningsfull forretningsmessig tolkning. EWMA gir bedre resultater enn SMA når det er viktig å oppdage trendvendinger raskt. Neste gang ser vi på rang- og persentilberegninger innenfor grupper ved hjelp av groupby().rank() og pd.qcut.
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «Eksponentielt vektet glidende gjennomsnitt» gratis?
Ja – hele teksten i «Eksponentielt vektet glidende gjennomsnitt» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Pandas & NumPy Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Eksponentielt vektet glidende gjennomsnitt»?
Bruk eksponentiell utjevning for å gi nyere verdier større vekt med ewm(span=), en standardteknikk i finansanalyse. Du øver på Pandas & NumPy Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Pandas & NumPy Academy?
Ingen tidligere erfaring er nødvendig. Pandas & NumPy Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.
Hvor lang tid tar leksjonen «Eksponentielt vektet glidende gjennomsnitt»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Pandas & NumPy Academy-leksjonen?
Ja. Alle Pandas & NumPy Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Rullerende vinduer
- Utvidende vinduer
- Eksponentielt vektet glidende gjennomsnitt
- Rangering og prosentiler innenfor grupper