Analýza časových řad v Pythonu s Pandas: Od základů po predikci

Proč se vyplatí umět pracovat s časovými řadami

Časové řady jsou doslova všude. Ceny akcií, teploty vzduchu, denní tržby e-shopu, návštěvnost webu, data ze senzorů IoT — kdykoli máte k dispozici data s časovým razítkem, máte časovou řadu. A pokud je chcete rozumně analyzovat, vizualizovat nebo dokonce předpovídat budoucí vývoj, potřebujete ty správné nástroje.

Python s knihovnou Pandas je v tomhle ohledu bezkonkurenční kombinace. Pandas totiž původně vznikl právě pro práci s finančními daty (což jsou v podstatě jen časové řady), a dodnes nabízí jedny z nejpropracovanějších nástrojů pro manipulaci s časově indexovanými daty. V aktuální verzi Pandas 3.0 (leden 2026) navíc přibylo několik vylepšení, díky kterým je práce s časovými řadami o trochu pohodlnější.

V tomto průvodci si společně projdeme celý workflow analýzy časových řad — od parsování datumů a vytváření DatetimeIndexu přes resampling a klouzavé průměry až po dekompozici a jednoduchou predikci. Všechny příklady jsou funkční a můžete je rovnou spustit.

Příprava prostředí a testovacích dat

Začneme tím nejdůležitějším — instalací a importem knihoven. Budete potřebovat Pandas 3.0+, NumPy a Matplotlib pro vizualizaci.

pip install pandas numpy matplotlib statsmodels --upgrade

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime

print(f"Pandas verze: {pd.__version__}")  # 3.0.x

Pro ukázky si vytvoříme realistický dataset, který simuluje denní tržby fiktivního e-shopu za dva roky. Data budou obsahovat trend, sezónnost i náhodný šum — prostě přesně to, co potkáte v praxi.

np.random.seed(42)

# Generování denních dat za 2 roky
datumy = pd.date_range(start="2024-01-01", end="2025-12-31", freq="D")

# Trend (postupný růst)
trend = np.linspace(50000, 80000, len(datumy))

# Týdenní sezónnost (víkendy mají vyšší tržby)
tydenni_sezonnost = np.array([
    0, 0, 0, 0, 5000, 12000, 8000  # Po-Ne
] * (len(datumy) // 7 + 1))[:len(datumy)]

# Měsíční sezónnost (prosinec = Vánoce, léto = slabší)
mesicni_sezonnost = np.array([
    -5000, -3000, 0, 2000, 3000, -2000,
    -4000, -3000, 1000, 3000, 5000, 15000
])
mesicni = np.array([mesicni_sezonnost[d.month - 1] for d in datumy])

# Náhodný šum
sum_hodnot = np.random.normal(0, 3000, len(datumy))

# Výsledné tržby
trzby = trend + tydenni_sezonnost + mesicni + sum_hodnot
trzby = np.maximum(trzby, 10000)  # minimální tržby

df = pd.DataFrame({
    "datum": datumy,
    "trzby": trzby.round(0),
    "pocet_objednavek": (trzby / np.random.uniform(800, 1200, len(datumy))).round(0).astype(int),
    "prumerna_hodnota": np.random.uniform(750, 1350, len(datumy)).round(0)
})

df = df.set_index("datum")
print(df.head(10))
print(f"\nCelkem záznamů: {len(df)}")
print(f"Období: {df.index.min()} až {df.index.max()}")

Práce s DatetimeIndex v Pandas 3.0

Srdcem celé práce s časovými řadami v Pandas je DatetimeIndex. Jakmile má váš DataFrame jako index sloupec s datumy, odemkne se vám celá sada speciálních operací — filtrování podle období, resampling, rolling windows a spousta dalšího. Upřímně, bez DatetimeIndexu se v analýze časových řad daleko nedostanete.

Parsování datumů z různých formátů

V praxi přicházejí datumy v nejrůznějších formátech. Někdy je to ISO formát, jindy český zápis s tečkami, občas něco úplně jiného. Pandas si s většinou poradí automaticky, ale občas mu prostě musíte trochu pomoct.

# Automatické rozpoznání formátu
df_raw = pd.DataFrame({
    "datum_str": ["2024-01-15", "15.3.2024", "2024/06/01", "1. ledna 2024"],
    "hodnota": [100, 200, 300, 400]
})

# pd.to_datetime zvládne většinu formátů
df_raw["datum"] = pd.to_datetime(df_raw["datum_str"], dayfirst=True)

# Specifikace formátu pro rychlejší parsování velkých datasetů
datumy_cz = pd.to_datetime(
    ["15.03.2024", "01.06.2024", "31.12.2024"],
    format="%d.%m.%Y"
)
print(datumy_cz)

Malý tip z praxe: pokud pracujete s velkým datasetem (řekněme miliony řádků), explicitní zadání parametru format vám parsování výrazně zrychlí. Pandas totiž jinak u každého řádku hádá formát, což stojí čas.

Filtrování podle období

DatetimeIndex umožňuje opravdu elegantní filtrování pomocí řetězců — říká se tomu partial string indexing. Tohle je jedna z věcí, kvůli kterým Pandas miluju.

# Všechna data za rok 2024
df_2024 = df.loc["2024"]

# Konkrétní měsíc
prosinec_2024 = df.loc["2024-12"]

# Rozsah datumů
q1_2025 = df.loc["2025-01":"2025-03"]

# Kombinace s podmínkami
vysoke_trzby = df.loc["2024-12"][df.loc["2024-12"]["trzby"] > 80000]
print(f"Dnů s tržbami nad 80 000 v prosinci 2024: {len(vysoke_trzby)}")

Užitečné vlastnosti přes dt accessor

Pokud máte datumy ve sloupci (ne v indexu), můžete k jejich vlastnostem přistupovat přes .dt accessor. Je to docela šikovné.

df_sloupec = df.reset_index()

# Extrakce komponent
df_sloupec["rok"] = df_sloupec["datum"].dt.year
df_sloupec["mesic"] = df_sloupec["datum"].dt.month
df_sloupec["den_v_tydnu"] = df_sloupec["datum"].dt.day_name()
df_sloupec["je_vikend"] = df_sloupec["datum"].dt.weekday >= 5
df_sloupec["tyden_v_roce"] = df_sloupec["datum"].dt.isocalendar().week

print(df_sloupec[["datum", "rok", "mesic", "den_v_tydnu", "je_vikend"]].head(7))

Resampling: Změna frekvence dat

Resampling je jedna z nejdůležitějších operací při práci s časovými řadami — a taky jedna z těch, kde se začátečníci nejvíc ztrácí. V zásadě jde o změnu frekvence dat. Například z denních na týdenní, měsíční nebo čtvrtletní. A funguje to i obráceně — z měsíčních dat můžete vytvořit denní a chybějící hodnoty doplnit interpolací.

Downsampling: z vyšší frekvence na nižší

# Denní data -> týdenní součty
tydenni = df["trzby"].resample("W").sum()
print("Týdenní tržby:")
print(tydenni.head())

# Denní data -> měsíční průměry
mesicni_prumer = df["trzby"].resample("ME").mean()
print("\nMěsíční průměrné tržby:")
print(mesicni_prumer.head())

# Čtvrtletní statistiky
ctvrtletni = df["trzby"].resample("QE").agg(["sum", "mean", "std", "min", "max"])
print("\nČtvrtletní přehled:")
print(ctvrtletni)

Důležitá poznámka: v Pandas 3.0 se změnily některé aliasy pro frekvence. Namísto "M" se teď používá "ME" (Month End), namísto "Q" je "QE" (Quarter End) a tak dále. Starší aliasy zatím fungují, ale dostanete varování. Moje rada — přejděte na nové aliasy hned, ušetříte si nepříjemná překvapení při příštím upgradu.

Upsampling: z nižší frekvence na vyšší

# Měsíční data -> denní data s interpolací
mesicni_data = df["trzby"].resample("ME").mean()

# Různé metody vyplnění
denni_ffill = mesicni_data.resample("D").ffill()       # dopředné vyplnění
denni_interp = mesicni_data.resample("D").interpolate() # lineární interpolace

# Porovnání
fig, ax = plt.subplots(figsize=(12, 5))
mesicni_data.plot(ax=ax, marker="o", label="Měsíční (originál)")
denni_interp.plot(ax=ax, alpha=0.7, label="Denní (interpolace)")
ax.set_title("Upsampling: z měsíčních na denní data")
ax.legend()
plt.tight_layout()
plt.savefig("upsampling.png", dpi=100)
plt.show()

Víceúrovňový resampling s agg()

# Měsíční statistiky pro více sloupců najednou
mesicni_report = df.resample("ME").agg({
    "trzby": ["sum", "mean", "max"],
    "pocet_objednavek": "sum",
    "prumerna_hodnota": "mean"
})

# Zploštění MultiIndex sloupců
mesicni_report.columns = ["_".join(col) for col in mesicni_report.columns]
print(mesicni_report.head())

Klouzavé průměry a rolling windows

Klouzavé (rolling) statistiky jsou naprosto klíčový nástroj pro vyhlazení šumu v časových řadách a identifikaci trendů. Metoda rolling() vytvoří posuvné okno dané velikosti a na každé pozici vypočítá zvolenou agregační funkci. Zní to možná složitě, ale ve skutečnosti je to docela intuitivní.

Základní klouzavé průměry

# 7denní klouzavý průměr (vyhlazení týdenní sezónnosti)
df["ma_7"] = df["trzby"].rolling(window=7).mean()

# 30denní klouzavý průměr (vyhlazení měsíčních výkyvů)
df["ma_30"] = df["trzby"].rolling(window=30).mean()

# 90denní klouzavý průměr (dlouhodobý trend)
df["ma_90"] = df["trzby"].rolling(window=90).mean()

# Vizualizace
fig, ax = plt.subplots(figsize=(14, 6))
df["trzby"].plot(ax=ax, alpha=0.3, label="Denní tržby")
df["ma_7"].plot(ax=ax, label="7denní MA")
df["ma_30"].plot(ax=ax, label="30denní MA")
df["ma_90"].plot(ax=ax, linewidth=2, label="90denní MA")
ax.set_title("Tržby e-shopu s klouzavými průměry")
ax.set_ylabel("Tržby (Kč)")
ax.legend()
plt.tight_layout()
plt.savefig("rolling_averages.png", dpi=100)
plt.show()

Další rolling statistiky

Klouzavý průměr je jen začátek. S rolling oknem můžete počítat i směrodatnou odchylku (což se hodí pro měření volatility), minima, maxima nebo třeba populární Bollinger Bands.

# Klouzavá směrodatná odchylka — měří volatilitu
df["rolling_std"] = df["trzby"].rolling(window=30).std()

# Klouzavé minimum a maximum
df["rolling_min"] = df["trzby"].rolling(window=30).min()
df["rolling_max"] = df["trzby"].rolling(window=30).max()

# Bollinger Bands (populární v technické analýze)
df["upper_band"] = df["ma_30"] + 2 * df["rolling_std"]
df["lower_band"] = df["ma_30"] - 2 * df["rolling_std"]

# Vizualizace Bollinger Bands
fig, ax = plt.subplots(figsize=(14, 6))
df["trzby"].plot(ax=ax, alpha=0.3, label="Denní tržby")
df["ma_30"].plot(ax=ax, label="30denní MA")
ax.fill_between(df.index, df["upper_band"], df["lower_band"],
                alpha=0.15, color="blue", label="Bollinger Bands")
ax.set_title("Bollinger Bands — detekce neobvyklých výkyvů")
ax.legend()
plt.tight_layout()
plt.show()

Exponenciálně vážený klouzavý průměr (EWMA)

Na rozdíl od jednoduchého klouzavého průměru, EWMA přikládá novějším datům větší váhu. To se hodí v situacích, kdy chcete, aby průměr rychleji reagoval na aktuální změny — třeba při sledování náhlého propadu tržeb.

# EWMA s parametrem span
df["ewma_7"] = df["trzby"].ewm(span=7).mean()
df["ewma_30"] = df["trzby"].ewm(span=30).mean()

# Porovnání SMA vs EWMA
fig, ax = plt.subplots(figsize=(14, 5))
df.loc["2025-01":"2025-06", "trzby"].plot(ax=ax, alpha=0.3, label="Denní")
df.loc["2025-01":"2025-06", "ma_7"].plot(ax=ax, label="SMA 7")
df.loc["2025-01":"2025-06", "ewma_7"].plot(ax=ax, label="EWMA 7")
ax.set_title("SMA vs EWMA — reakce na změny")
ax.legend()
plt.tight_layout()
plt.show()

Posuny a diference: shift() a diff()

Operace posunu (shift) a diference (diff) jsou základní stavební kameny pro analýzu změn v čase. Bez nich se neobejdete — používají se při výpočtu denních přírůstků, procentuálních změn nebo při přípravě dat pro predikční modely.

Posun dat v čase

# Posun o 1 den dopředu (lag) — hodnota z předchozího dne
df["trzby_vcera"] = df["trzby"].shift(1)

# Posun o 7 dní — hodnota ze stejného dne minulý týden
df["trzby_pred_tydnem"] = df["trzby"].shift(7)

# Posun dozadu (lead) — hodnota zítřejšího dne
df["trzby_zitra"] = df["trzby"].shift(-1)

print(df[["trzby", "trzby_vcera", "trzby_pred_tydnem"]].head(10))

Výpočet změn a přírůstků

# Absolutní denní změna
df["denni_zmena"] = df["trzby"].diff()

# Procentuální denní změna
df["denni_zmena_pct"] = df["trzby"].pct_change() * 100

# Týdenní změna (oproti stejnému dni minulý týden)
df["tydenni_zmena_pct"] = df["trzby"].pct_change(periods=7) * 100

# Měsíční změna
df["mesicni_zmena_pct"] = df["trzby"].pct_change(periods=30) * 100

print(df[["trzby", "denni_zmena", "denni_zmena_pct"]].dropna().head())

Kumulativní statistiky

# Kumulativní součet tržeb od začátku roku
df_2025 = df.loc["2025"]
df_2025_kum = df_2025.copy()
df_2025_kum["kumul_trzby"] = df_2025_kum["trzby"].cumsum()

# Expanding window — průběžný průměr od začátku
df_2025_kum["prubezny_prumer"] = df_2025_kum["trzby"].expanding().mean()

fig, axes = plt.subplots(2, 1, figsize=(14, 8))
df_2025_kum["kumul_trzby"].plot(ax=axes[0], title="Kumulativní tržby 2025")
axes[0].set_ylabel("Kč")
df_2025_kum["prubezny_prumer"].plot(ax=axes[1], title="Průběžný průměr tržeb 2025")
axes[1].set_ylabel("Kč")
plt.tight_layout()
plt.show()

Sezónní dekompozice časové řady

Tady se dostáváme k opravdu zajímavé části. Každou časovou řadu je totiž možné rozložit na tři základní složky: trend (dlouhodobý směr), sezónnost (opakující se vzory) a rezidua (náhodný šum, který nejde vysvětlit prvními dvěma). Tahle dekompozice je naprosto klíčová pro pochopení toho, co se vlastně v datech děje.

from statsmodels.tsa.seasonal import seasonal_decompose

# Dekompozice s periodou 7 dní (týdenní sezónnost)
dekompozice = seasonal_decompose(
    df["trzby"],
    model="additive",
    period=7
)

# Vizualizace všech složek
fig = dekompozice.plot()
fig.set_size_inches(14, 10)
fig.suptitle("Dekompozice časové řady tržeb", fontsize=14, y=1.02)
plt.tight_layout()
plt.savefig("dekompozice.png", dpi=100)
plt.show()

# Přístup k jednotlivým složkám
print("Trend (první hodnoty):")
print(dekompozice.trend.dropna().head())
print("\nSezónní složka (jeden cyklus):")
print(dekompozice.seasonal.head(7))

Parametr model určuje typ dekompozice. Použijte "additive", pokud je amplituda sezónních výkyvů přibližně konstantní. Ale pozor — pokud výkyvy rostou společně s úrovní řady (třeba tržby rostou a s nimi i absolutní výkyvy), zvolte raději "multiplicative". V praxi to udělá obrovský rozdíl.

Detekce odlehlých hodnot v časových řadách

Detekce anomálií v časových řadách je trochu ošidná záležitost. Nemůžete totiž použít standardní metody (jako IQR) bez kontextu — hodnota, která je v lednu naprosto normální, může být v srpnu anomálií. Proto potřebujete metody, které zohledňují časový kontext.

Tady jsou dvě osvědčené metody, které v praxi fungují spolehlivě.

# Metoda 1: Z-skóre na reziduích po dekompozici
residua = dekompozice.resid.dropna()
z_scores = (residua - residua.mean()) / residua.std()
outliers_z = df.loc[z_scores[z_scores.abs() > 3].index]
print(f"Nalezeno {len(outliers_z)} odlehlých hodnot (Z-skóre > 3)")

# Metoda 2: Klouzavé Bollinger Bands
ma = df["trzby"].rolling(window=30).mean()
std = df["trzby"].rolling(window=30).std()
outliers_bb = df[(df["trzby"] > ma + 3 * std) | (df["trzby"] < ma - 3 * std)]
print(f"Nalezeno {len(outliers_bb)} odlehlých hodnot (Bollinger Bands)")

# Vizualizace
fig, ax = plt.subplots(figsize=(14, 5))
df["trzby"].plot(ax=ax, alpha=0.5, label="Tržby")
if len(outliers_z) > 0:
    ax.scatter(outliers_z.index, outliers_z["trzby"],
               color="red", s=50, zorder=5, label="Anomálie")
ax.set_title("Detekce anomálií v tržbách")
ax.legend()
plt.tight_layout()
plt.show()

Jednoduchá predikce pomocí ARIMA

A teď to nejzajímavější — predikce budoucích hodnot. Tady se z analytika stává (trochu) věštec. Model ARIMA (AutoRegressive Integrated Moving Average) je klasická a osvědčená volba pro předpovídání časových řad. Skládá se ze tří parametrů: p (autoregresní řád), d (stupeň diferenciace) a q (řád klouzavého průměru).

Test stacionarity

ARIMA vyžaduje stacionární data — jinými slovy data bez trendu a s konstantním rozptylem. Stacionaritu ověříme pomocí Augmented Dickey-Fuller testu. Pokud vám to zní akademicky, nebojte se — v praxi jde jen o jeden řádek kódu.

from statsmodels.tsa.stattools import adfuller

# Test na originálních datech
vysledek = adfuller(df["trzby"].dropna())
print(f"ADF statistika: {vysledek[0]:.4f}")
print(f"p-hodnota: {vysledek[1]:.6f}")
print(f"Kritické hodnoty: {vysledek[4]}")

if vysledek[1] < 0.05:
    print("-> Data JSOU stacionární (zamítáme nulovou hypotézu)")
else:
    print("-> Data NEJSOU stacionární (potřebujeme diferenciaci)")

# Diferenciace — odstranění trendu
df_diff = df["trzby"].diff().dropna()
vysledek_diff = adfuller(df_diff)
print(f"\nPo diferenciaci - p-hodnota: {vysledek_diff[1]:.6f}")

Sestavení a trénování modelu ARIMA

from statsmodels.tsa.arima.model import ARIMA

# Rozdělení na trénovací a testovací sadu
train = df["trzby"].loc[:"2025-09-30"]
test = df["trzby"].loc["2025-10-01":]

# Sestavení modelu ARIMA(7,1,7) — týdenní sezónnost
model = ARIMA(train, order=(7, 1, 7))
model_fit = model.fit()

print(model_fit.summary())
print(f"\nAIC: {model_fit.aic:.2f}")
print(f"BIC: {model_fit.bic:.2f}")

Predikce a vyhodnocení

from sklearn.metrics import mean_absolute_error, mean_squared_error

# Predikce na testovací období
predikce = model_fit.forecast(steps=len(test))

# Vyhodnocení přesnosti
mae = mean_absolute_error(test, predikce)
rmse = np.sqrt(mean_squared_error(test, predikce))
mape = (np.abs((test - predikce) / test).mean()) * 100

print(f"MAE:  {mae:.0f} Kč")
print(f"RMSE: {rmse:.0f} Kč")
print(f"MAPE: {mape:.1f} %")

# Vizualizace predikce vs skutečnost
fig, ax = plt.subplots(figsize=(14, 6))
train.loc["2025-07-01":].plot(ax=ax, label="Trénovací data")
test.plot(ax=ax, label="Skutečnost")
predikce.plot(ax=ax, label="Predikce ARIMA", linestyle="--")
ax.set_title("ARIMA predikce tržeb — říjen-prosinec 2025")
ax.set_ylabel("Tržby (Kč)")
ax.legend()
plt.tight_layout()
plt.savefig("arima_predikce.png", dpi=100)
plt.show()

Praktické tipy pro práci s časovými řadami

Na závěr ještě pár tipů z praxe, které mi osobně ušetřily spoustu času (a nervů) při práci s reálnými daty.

1. Vždy kontrolujte chybějící datumy

Tohle je věc, na kterou se snadno zapomene. Dataset může vypadat kompletní, ale pokud v něm chybí pár dnů (třeba svátky, kdy se nelogovalo), celá analýza se vám může rozhodit.

# Vytvoření kompletního datumového rozsahu
kompletni_rozsah = pd.date_range(start=df.index.min(), end=df.index.max(), freq="D")
chybejici = kompletni_rozsah.difference(df.index)
print(f"Chybějících dnů: {len(chybejici)}")

# Doplnění chybějících dat
df_kompletni = df.reindex(kompletni_rozsah)
df_kompletni["trzby"] = df_kompletni["trzby"].interpolate(method="time")

2. Časové zóny

Práce s časovými zónami je v Pythonu notoricky otravná, ale Pandas to zvládá poměrně elegantně.

# Nastavení časové zóny
df_tz = df.copy()
df_tz.index = df_tz.index.tz_localize("Europe/Prague")

# Převod mezi zónami
df_utc = df_tz.copy()
df_utc.index = df_utc.index.tz_convert("UTC")
print(df_tz.index[0], "->", df_utc.index[0])

3. Pozor na Copy-on-Write v Pandas 3.0

Tohle je asi největší „gotcha" při přechodu na Pandas 3.0. Copy-on-Write je teď výchozí chování, což znamená, že jakýkoli výřez DataFrame je vždy kopie, nikdy pohled. Pokud jste zvyklí měnit originální data přes výřez — tak to už prostě nefunguje. Místo řetězeného přiřazení používejte .loc[].

# Správný způsob v Pandas 3.0
df.loc["2025-01-01":"2025-01-07", "trzby"] = 0  # funguje
# df["2025-01":"2025-01"]["trzby"] = 0  # nefunguje (Copy-on-Write)

4. Výkon při práci s velkými datasety

# Explicitní format parametr pro rychlejší parsování
velky_df = pd.read_csv(
    "velky_dataset.csv",
    parse_dates=["datum"],
    date_format="%Y-%m-%d"  # nový parametr v Pandas 3.0
)

# Použití kategorických dat pro opakující se hodnoty
df["den_tydne"] = df.index.day_name()
df["den_tydne"] = df["den_tydne"].astype("category")

# Kontrola paměti
print(df.memory_usage(deep=True))

Často kladené otázky (FAQ)

Jaký je rozdíl mezi resample() a rolling() v Pandas?

Metoda resample() mění frekvenci dat — třeba z denních na měsíční. Data se seskupí do nových časových intervalů a agregují (součet, průměr apod.). Naproti tomu rolling() zachovává původní frekvenci a na každém bodě vypočítá statistiku z posuvného okna dané velikosti. Jednoduše řečeno: resampling pro souhrnné reporty, rolling pro vyhlazení dat a detekci trendů.

Jak zpracovat chybějící hodnoty v časové řadě?

U časových řad rozhodně nedoporučuju nahrazovat chybějící hodnoty průměrem celé řady — to by ignorovalo trend a sezónnost. Lepší volby jsou dopředné vyplnění (ffill()), zpětné vyplnění (bfill()) nebo interpolace (interpolate(method="time")), která zohledňuje časové vzdálenosti mezi body. Pro krátké mezery je interpolace ideální, pro delší výpadky zvažte sezónní interpolaci.

Co se změnilo v Pandas 3.0 pro práci s časovými řadami?

Nejvýznamnější změny zahrnují nové frekvenční aliasy ("ME" místo "M", "QE" místo "Q"), nové offsetové třídy HalfYearBegin a HalfYearEnd, režim Copy-on-Write jako výchozí nastavení a nový parametr date_format pro specifikaci formátu při čtení CSV. Přechod z Pandas 2.x je celkem plynulý — doporučuju nejdřív upgradovat na 2.3 a vyřešit všechny deprecation warnings.

Kdy použít ARIMA a kdy SARIMA pro predikci?

ARIMA se hodí pro časové řady bez výrazné sezónnosti nebo tam, kde jste sezónnost předem odstranili. Pokud vaše data mají jasnou opakující se sezónní složku (třeba měsíční výkyvy v tržbách), sáhněte po SARIMA, která rozšiřuje ARIMA o sezónní parametry (P, D, Q, s). Praktické pravidlo: pokud dekompozice ukáže jasný sezónní vzor, volte SARIMA.

Jak velký dataset potřebuji pro spolehlivou analýzu časové řady?

Obecné pravidlo říká, že potřebujete alespoň 2-3 kompletní cykly sezónnosti. Analyzujete měsíční sezónnost? Pak potřebujete minimálně 2-3 roky denních dat. Pro týdenní vzory stačí méně, řekněme 3-6 měsíců. Pro model ARIMA se doporučuje mít alespoň 50 pozorování, ideálně 100+. Víc dat je samozřejmě lepší, ale pozor — příliš stará data můžou obsahovat vzory, které už dávno nejsou relevantní.