Feature Engineering v Pythonu: Průvodce (2026)

Co je feature engineering a proč na něm záleží

Máte vyčištěná data, rozumíte jejich struktuře — a co teď? Jestli jste si mysleli, že stačí data nacpat do modelu a čekat na zázrak, mám pro vás špatnou zprávu. Kvalita příznaků (features), které do modelu vstupují, rozhoduje o výsledku mnohem víc než volba samotného algoritmu. Říká se tomu feature engineering — inženýrství příznaků — a upřímně, je to dovednost, která odděluje průměrné modely od těch opravdu dobrých.

Feature engineering je proces transformace surových dat na příznaky, které lépe reprezentují podstatné vzory pro strojové učení. Zahrnuje kódování kategorických proměnných, škálování čísel, extrakci informací z datumů, vytváření interakcí mezi proměnnými a mnoho dalšího. A tady je klíčová věc — výzkumy opakovaně ukazují, že volba preprocessingu může mít na přesnost modelu větší dopad než ladění hyperparametrů. Takže ten čas strávený nad feature engineeringem se vám vrátí.

V tomto průvodci si projdeme všechny klíčové techniky krok za krokem. Používáme Pandas 3.0, scikit-learn 1.8 a NumPy 2.4 — tedy aktuální stabilní verze z přelomu let 2025/2026. Každou techniku si ukážeme na funkčních příkladech, které můžete rovnou použít ve svých projektech.

Příprava prostředí a ukázkových dat

Než se pustíme do samotného feature engineeringu, připravme si prostředí. Nainstalujte potřebné knihovny a vytvořte si ukázkový dataset, se kterým budeme pracovat v celém článku.

pip install pandas scikit-learn numpy feature-engine

# Ověření verzí
import pandas as pd
import numpy as np
import sklearn

print(f"Pandas: {pd.__version__}")       # 3.0.x
print(f"NumPy: {np.__version__}")         # 2.4.x
print(f"scikit-learn: {sklearn.__version__}")  # 1.8.x

Pro příklady vytvoříme dataset simulující data o zákaznících e-shopu. Obsahuje mix numerických, kategorických i datumových příznaků — přesně ten typ dat, který potkáte v reálné praxi.

import pandas as pd
import numpy as np

np.random.seed(42)
n = 500

data = {
    "vek": np.random.normal(35, 10, n).clip(18, 70).astype(int),
    "prijem": np.random.lognormal(10.5, 0.6, n).astype(int),
    "pocet_objednavek": np.random.poisson(5, n),
    "prumerna_hodnota": np.random.lognormal(6.5, 0.8, n).round(2),
    "kategorie": np.random.choice(
        ["elektronika", "obleceni", "potraviny", "sport", "domacnost"], n
    ),
    "mesto": np.random.choice(
        ["Praha", "Brno", "Ostrava", "Plzeň", "Liberec", "Olomouc"], n
    ),
    "kanal": np.random.choice(["web", "mobilni_app", "email", "socialni_site"], n),
    "datum_registrace": pd.date_range("2020-01-01", periods=n, freq="3D"),
    "posledni_nakup": pd.to_datetime("2026-03-01") - pd.to_timedelta(
        np.random.exponential(60, n).astype(int), unit="D"
    ),
}

df = pd.DataFrame(data)

# Cílová proměnná — zda zákazník odejde (churn)
df["churn"] = (
    (df["pocet_objednavek"] < 3).astype(int) * 0.4
    + (df["prumerna_hodnota"] < 500).astype(int) * 0.3
    + np.random.random(n) * 0.3
).round().astype(int)

print(df.head())
print(f"\nRozměry: {df.shape}")
print(f"Poměr churn: {df['churn'].mean():.2%}")

Kódování kategorických proměnných

Většina algoritmů strojového učení neumí pracovat s textovými hodnotami. Kategorické proměnné proto musíte převést na čísla. Ale pozor — způsob kódování záleží na typu dat a na modelu, který plánujete použít. Tohle je místo, kde se často dělají chyby.

One-Hot Encoding (jednoznačné kódování)

One-hot encoding vytvoří pro každou kategorii vlastní binární sloupec. Je ideální pro nominální proměnné (tedy takové bez přirozeného pořadí) a modely citlivé na ordinální vztahy, jako je lineární regrese.

from sklearn.preprocessing import OneHotEncoder

ohe = OneHotEncoder(sparse_output=False, drop="first")
encoded = ohe.fit_transform(df[["kategorie"]])

# Názvy nových sloupců
feature_names = ohe.get_feature_names_out(["kategorie"])
df_encoded = pd.DataFrame(encoded, columns=feature_names, index=df.index)

print(df_encoded.head())
print(f"Počet nových příznaků: {df_encoded.shape[1]}")

Parametr drop="first" odstraní první kategorii z každé proměnné, čímž se vyhnete pasti multikolinearity (dummy variable trap). Pro stromové modely (Random Forest, XGBoost) to nutné není, ale pro lineární modely je to zásadní — bez toho by vám model mohl dávat nespolehlivé koeficienty.

Ordinální kódování

Pokud má proměnná přirozené pořadí (třeba vzdělání: základní < střední < vysoké), je škoda to ignorovat. Použijte ordinální kódování, které toto pořadí zachová.

from sklearn.preprocessing import OrdinalEncoder

# Příklad: hodnocení spokojenosti zákazníka
df["spokojenost"] = np.random.choice(
    ["velmi_nespokojen", "nespokojen", "neutralni", "spokojen", "velmi_spokojen"], n
)

oe = OrdinalEncoder(categories=[[
    "velmi_nespokojen", "nespokojen", "neutralni", "spokojen", "velmi_spokojen"
]])

df["spokojenost_encoded"] = oe.fit_transform(df[["spokojenost"]])
print(df[["spokojenost", "spokojenost_encoded"]].drop_duplicates().sort_values(
    "spokojenost_encoded"
))

Target Encoding (kódování cílovou proměnnou)

Target encoding nahradí každou kategorii průměrnou hodnotou cílové proměnné pro danou kategorii. Je to elegantní technika a od scikit-learn 1.3 je k dispozici přímo jako TargetEncoder s vestavěnou ochranou proti přeučení.

from sklearn.preprocessing import TargetEncoder

te = TargetEncoder(smooth="auto", cv=5, random_state=42)

# fit_transform používá interní cross-fitting proti data leakage
df["mesto_target"] = te.fit_transform(
    df[["mesto"]], df["churn"]
)

print(df.groupby("mesto")["mesto_target"].mean().sort_values())

Target encoding je obzvlášť užitečný pro proměnné s vysokou kardinalitou (hodně unikátních hodnot), kde by one-hot encoding vytvořil stovky sloupců. To je v praxi docela běžné — představte si třeba PSČ nebo ID produktu. Metoda fit_transform třídy TargetEncoder automaticky používá schéma křížového přizpůsobení, které rozdělí data na k foldů a každý fold zakóduje pomocí ostatních. Tím se minimalizuje riziko přeučení, což je u target encodingu jinak velký problém.

Transformace numerických příznaků

Kategorické proměnné máme za sebou, ale numerické příznaky taky potřebují péči. Různé modely mají různé požadavky na škálu, rozložení a tvar dat — a správná transformace může výrazně zlepšit výsledky.

Škálování: StandardScaler vs MinMaxScaler

Modely založené na vzdálenostech (KNN, SVM, logistická regrese) jsou citlivé na měřítko příznaků. Příznak s rozsahem 0–1 000 000 bude jednoduše dominovat nad příznakem s rozsahem 0–1. To nechcete.

from sklearn.preprocessing import StandardScaler, MinMaxScaler

# StandardScaler: průměr = 0, směrodatná odchylka = 1
scaler_std = StandardScaler()
df["prijem_standard"] = scaler_std.fit_transform(df[["prijem"]])

# MinMaxScaler: převod na rozsah [0, 1]
scaler_mm = MinMaxScaler()
df["prijem_minmax"] = scaler_mm.fit_transform(df[["prijem"]])

print(df[["prijem", "prijem_standard", "prijem_minmax"]].describe().round(3))

Základní pravidlo: StandardScaler je vhodný pro lineární modely a neuronové sítě. MinMaxScaler se hodí, když potřebujete hodnoty v konkrétním rozsahu (třeba 0 až 1). A co stromové modely? Ty škálování nepotřebují vůbec — Random Forest, Gradient Boosting ani XGBoost s měřítkem problém nemají.

Logaritmická transformace zkosených dat

Proměnné jako příjem nebo cena mají často silně pravostranné rozložení — hodně malých hodnot a pár extrémně velkých. Logaritmická transformace tohle rozložení vyrovná a lineárním modelům se s takovými daty pracuje mnohem lépe.

# Vizualizace rozložení před a po transformaci
import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2, figsize=(12, 4))

df["prijem"].hist(bins=50, ax=axes[0])
axes[0].set_title("Původní rozložení příjmu")

df["prijem_log"] = np.log1p(df["prijem"])  # log1p = log(1 + x), bezpečné pro 0
df["prijem_log"].hist(bins=50, ax=axes[1])
axes[1].set_title("Rozložení po log transformaci")

plt.tight_layout()
plt.savefig("prijem_transformace.png", dpi=100)
plt.show()

Funkce np.log1p() je bezpečnější než np.log(), protože zvládne nulové hodnoty (vypočítá log(1 + x)). Pro inverzní transformaci pak použijte np.expm1().

Binning: převod spojitých hodnot na kategorie

Někdy je užitečné rozdělit spojitou proměnnou do intervalů. Zní to jako krok zpátky (proč bychom z čísla dělali kategorii?), ale v praxi to může modelu pomoct zachytit nelineární vztahy. Scikit-learn nabízí KBinsDiscretizer, který tohle zvládne s několika strategiemi rozdělení.

from sklearn.preprocessing import KBinsDiscretizer

kbd = KBinsDiscretizer(n_bins=5, encode="ordinal", strategy="quantile")
df["vek_bin"] = kbd.fit_transform(df[["vek"]]).astype(int)

# Podívejme se na hranice košů
print("Hranice košů:", kbd.bin_edges_[0].round(1))
print(df.groupby("vek_bin")["churn"].mean().round(3))

Strategie "quantile" zajistí, že každý koš bude obsahovat přibližně stejný počet pozorování — takže nemáte jeden koš s tisíci záznamy a druhý s pěti. Alternativa "uniform" rozdělí rozsah na stejně široké intervaly a "kmeans" použije algoritmus K-means pro nalezení optimálních hranic.

Extrakce příznaků z datumů a času

Datumové sloupce jsou doslova zlatý důl pro feature engineering. A myslím to vážně. Jeden jediný datum může vygenerovat desítky užitečných příznaků — den v týdnu, měsíc, čtvrtletí, jestli je víkend, kolik dní uplynulo od určité události…

# Extrakce příznaků z data registrace
df["rok_registrace"] = df["datum_registrace"].dt.year
df["mesic_registrace"] = df["datum_registrace"].dt.month
df["den_v_tydnu"] = df["datum_registrace"].dt.dayofweek
df["je_vikend"] = df["den_v_tydnu"].isin([5, 6]).astype(int)
df["ctvrtleti"] = df["datum_registrace"].dt.quarter

# Počet dní od registrace (stáří zákazníka)
dnes = pd.Timestamp("2026-03-13")
df["dny_od_registrace"] = (dnes - df["datum_registrace"]).dt.days

# Počet dní od posledního nákupu (recency)
df["dny_od_nakupu"] = (dnes - df["posledni_nakup"]).dt.days

print(df[["datum_registrace", "rok_registrace", "mesic_registrace",
          "den_v_tydnu", "je_vikend", "dny_od_registrace"]].head())

Příznak recency (dny od posledního nákupu) je jedním z nejsilnějších prediktorů zákaznického churnu. Ze své zkušenosti můžu říct, že tahle jednoduchá metrika dokáže někdy překonat mnohem složitější příznaky. Spolu s frequency (počet objednávek) a monetary (průměrná hodnota) tvoří klasický RFM model, který se v marketingové analytice používá už desítky let — a pořád funguje skvěle.

Cyklické kódování časových příznaků

Tady je věc, na kterou se často zapomíná. Měsíc nebo den v týdnu jsou cyklické proměnné — prosinec (12) je blíže lednu (1) než červnu (6). Obyčejné ordinální kódování tohle nezachytí. Řešení? Sinusová a kosinusová transformace.

# Cyklické kódování měsíce
df["mesic_sin"] = np.sin(2 * np.pi * df["mesic_registrace"] / 12)
df["mesic_cos"] = np.cos(2 * np.pi * df["mesic_registrace"] / 12)

# Cyklické kódování dne v týdnu
df["den_sin"] = np.sin(2 * np.pi * df["den_v_tydnu"] / 7)
df["den_cos"] = np.cos(2 * np.pi * df["den_v_tydnu"] / 7)

print(df[["mesic_registrace", "mesic_sin", "mesic_cos"]].drop_duplicates().sort_values(
    "mesic_registrace"
).head(12))

Ano, tato technika vytvoří dva nové příznaky místo jednoho. Ale model díky nim dokáže správně pochopit cyklickou povahu času, a to za ten jeden sloupec navíc stojí. Používá se běžně i pro hodinu dne nebo den v roce.

Vytváření interakčních příznaků

Někdy je vztah mezi příznaky a cílovou proměnnou skrytý v kombinaci dvou nebo více příznaků. Samotný věk a samotný příjem nemusí být silnými prediktory, ale jejich poměr (příjem dělený věkem) může odhalit zajímavý vzor, který by model sám neobjevil.

Ruční vytváření interakcí

Začněme tím nejjednodušším přístupem — ručně vytvořenými příznaky na základě znalosti problému.

# Poměrové příznaky
df["hodnota_na_objednavku"] = df["prumerna_hodnota"] * df["pocet_objednavek"]
df["prijem_na_vek"] = df["prijem"] / df["vek"]

# Kombinace kategorických a numerických příznaků
df["celkova_utrata"] = df["pocet_objednavek"] * df["prumerna_hodnota"]

print(df[["pocet_objednavek", "prumerna_hodnota",
          "hodnota_na_objednavku", "celkova_utrata"]].describe().round(2))

Automatické polynomiální příznaky

Pro systematické generování interakcí použijte PolynomialFeatures ze scikit-learn. Vytvoří všechny polynomiální kombinace do zadaného stupně — takže nemusíte vymýšlet každou interakci ručně.

from sklearn.preprocessing import PolynomialFeatures

# Vybereme jen pár numerických příznaků
num_features = df[["vek", "pocet_objednavek", "prumerna_hodnota"]].values

poly = PolynomialFeatures(degree=2, interaction_only=True, include_bias=False)
interactions = poly.fit_transform(num_features)

feature_names = poly.get_feature_names_out(
    ["vek", "pocet_objednavek", "prumerna_hodnota"]
)
df_interactions = pd.DataFrame(interactions, columns=feature_names, index=df.index)

print(f"Původní příznaky: 3")
print(f"Po přidání interakcí: {df_interactions.shape[1]}")
print(df_interactions.head())

Parametr interaction_only=True generuje pouze interakce (součiny), ne kvadráty jednotlivých příznaků. A to je obvykle to, co chcete. Kvadráty často nepřinášejí novou informaci, ale zvyšují riziko přeučení a zpomalují trénink.

Feature engineering v jednom pipeline

Tak, ukázali jsme si jednotlivé techniky izolovaně. V praxi ale potřebujete všechny kroky spojit do jednoho reproducibilního celku — a přesně k tomu slouží Pipeline a ColumnTransformer ze scikit-learn.

Pokud jste četli náš průvodce scikit-learn pipeline, tento kód vám bude povědomý. Tady ho rozšíříme o pokročilejší feature engineering.

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import (
    StandardScaler, OneHotEncoder, OrdinalEncoder,
    PolynomialFeatures, FunctionTransformer
)
from sklearn.impute import SimpleImputer
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score

# Definice sloupců podle typu
numericke_sloupce = ["vek", "prijem", "pocet_objednavek", "prumerna_hodnota"]
kategoricke_sloupce = ["kategorie", "kanal"]

# Pipeline pro numerické příznaky
numericka_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("log_transform", FunctionTransformer(np.log1p, validate=True)),
    ("scaler", StandardScaler()),
])

# Pipeline pro kategorické příznaky
kategoricka_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(drop="first", sparse_output=False,
                              handle_unknown="ignore")),
])

# Spojení do ColumnTransformeru
preprocessor = ColumnTransformer([
    ("num", numericka_pipeline, numericke_sloupce),
    ("cat", kategoricka_pipeline, kategoricke_sloupce),
])

# Kompletní pipeline s modelem
pipeline = Pipeline([
    ("preprocessor", preprocessor),
    ("classifier", GradientBoostingClassifier(
        n_estimators=200, max_depth=4, random_state=42
    )),
])

# Příprava dat
X = df[numericke_sloupce + kategoricke_sloupce]
y = df["churn"]

# Křížová validace
scores = cross_val_score(pipeline, X, y, cv=5, scoring="roc_auc")
print(f"ROC AUC: {scores.mean():.4f} (+/- {scores.std():.4f})")

Hlavní výhoda tohoto přístupu? Celý preprocessing se automaticky aplikuje jen na trénovací data v každém foldu křížové validace. Žádný únik dat, žádné zapomenuté kroky. A navíc — pipeline můžete uložit a nasadit do produkce jako jeden objekt pomocí joblib.

Přidání vlastních transformátorů

Scikit-learn umožňuje vytvářet i vlastní transformátory, což se hodí, když potřebujete logiku, kterou žádný vestavěný transformátor nepokrývá. Tady je příklad transformátoru pro extrakci příznaků z datumových sloupců.

from sklearn.base import BaseEstimator, TransformerMixin

class DateFeatureExtractor(BaseEstimator, TransformerMixin):
    """Extrahuje příznaky z datumových sloupců."""

    def __init__(self, reference_date="2026-03-13"):
        self.reference_date = pd.Timestamp(reference_date)

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        X = X.copy()
        result = pd.DataFrame(index=X.index)
        for col in X.columns:
            dt = pd.to_datetime(X[col])
            result[f"{col}_dny"] = (self.reference_date - dt).dt.days
            result[f"{col}_mesic"] = dt.dt.month
            result[f"{col}_den_tydne"] = dt.dt.dayofweek
            result[f"{col}_mesic_sin"] = np.sin(2 * np.pi * dt.dt.month / 12)
            result[f"{col}_mesic_cos"] = np.cos(2 * np.pi * dt.dt.month / 12)
        return result

# Použití v rozšířeném pipeline
datumove_sloupce = ["datum_registrace", "posledni_nakup"]

preprocessor_v2 = ColumnTransformer([
    ("num", numericka_pipeline, numericke_sloupce),
    ("cat", kategoricka_pipeline, kategoricke_sloupce),
    ("date", DateFeatureExtractor(), datumove_sloupce),
])

pipeline_v2 = Pipeline([
    ("preprocessor", preprocessor_v2),
    ("classifier", GradientBoostingClassifier(
        n_estimators=200, max_depth=4, random_state=42
    )),
])

X_v2 = df[numericke_sloupce + kategoricke_sloupce + datumove_sloupce]
scores_v2 = cross_val_score(pipeline_v2, X_v2, y, cv=5, scoring="roc_auc")
print(f"ROC AUC (s datumovými příznaky): {scores_v2.mean():.4f} (+/- {scores_v2.std():.4f})")

Výběr příznaků: méně je někdy více

Feature engineering často vede k explozi počtu příznaků. Víc příznaků ale neznamená lepší model — vlastně naopak. Irelevantní příznaky mohou model zmást, zpomalit trénink a zvýšit riziko přeučení. Proto je důležité po generování příznaků provést jejich selekci.

from sklearn.feature_selection import SelectKBest, mutual_info_classif

# Transformace dat pomocí preprocessoru
X_transformed = preprocessor_v2.fit_transform(X_v2, y)

# Výběr nejlepších příznaků pomocí vzájemné informace
selector = SelectKBest(score_func=mutual_info_classif, k=10)
X_selected = selector.fit_transform(X_transformed, y)

# Které příznaky byly vybrány?
feature_names_all = preprocessor_v2.get_feature_names_out()
selected_mask = selector.get_support()
selected_features = feature_names_all[selected_mask]

print("Vybrané příznaky:")
for name, score in sorted(
    zip(selected_features, selector.scores_[selected_mask]),
    key=lambda x: x[1], reverse=True
):
    print(f"  {name}: {score:.4f}")

Alternativně můžete použít VarianceThreshold pro odstranění příznaků s téměř nulovou variabilitou, nebo SelectFromModel s modelem jako Random Forest, který přiřazuje důležitost příznaků. Každá metoda má své místo — nejlepší je zkusit víc přístupů a porovnat výsledky.

Praktické tipy pro feature engineering

Začněte jednoduše. Nejdřív vyzkoušejte základní techniky (škálování, one-hot encoding) a složitější přidávejte postupně. Sledujte, jak se mění výkon modelu s každým přidaným příznakem.
Znalost domény je klíčová. Nejlepší příznaky nevznikají aplikací algoritmů, ale pochopením problému. Pokud víte, že v e-commerce je recency silný prediktor churnu, vytvořte ten příznak explicitně — žádný automatický nástroj ho za vás nevymyslí lépe.
Pozor na data leakage. Tohle je asi nejčastější chyba. Nikdy nepoužívejte informace z budoucnosti nebo z testovací sady při vytváření příznaků. Pipeline vám s tím pomůže automaticky, tak ho používejte.
Stromové modely vs. lineární modely. Stromové modely (Random Forest, XGBoost, LightGBM) nepotřebují škálování a zvládnou ordinální kódování. Lineární modely naopak vyžadují škálování a one-hot encoding. Připravujte příznaky s ohledem na to, jaký model budete trénovat.
Sledujte korelace. Silně korelované příznaky přidávají redundantní informaci a můžou zhoršit interpretovatelnost modelu. Odstraňte je nebo použijte PCA pro redukci dimenzionality.
Logujte své experimenty. Zaznamenávejte si, které příznaky jste vytvořili a jaký měly dopad na výkon. Věřte mi, za dva týdny si nebudete pamatovat, proč jste ten konkrétní příznak přidali.

Nejčastější dotazy (FAQ)

Jaký je rozdíl mezi feature engineering a feature selection?

Feature engineering je proces vytváření nových příznaků z existujících dat — kódování kategorií, transformace čísel, extrakce z datumů. Feature selection je proces výběru nejdůležitějších příznaků a odstranění irelevantních. V praxi se tyto dva kroky doplňují: nejdřív příznaky vytvoříte a pak vyberete ty nejužitečnější.

Kdy použít one-hot encoding a kdy target encoding?

One-hot encoding je bezpečná volba pro proměnné s nízkou kardinalitou (do cca 10–15 unikátních hodnot). Pro proměnné s vysokou kardinalitou (stovky hodnot, třeba PSČ nebo ID produktu) použijte target encoding — vyhnete se vytváření stovek sloupců, které by model stejně neuměl efektivně využít. Target encoding ale vyžaduje ochranu proti přeučení, kterou scikit-learn TargetEncoder řeší automaticky.

Musím škálovat data pro Random Forest nebo XGBoost?

Ne. Stromové modely škálování nepotřebují. Rozhodovací stromy dělí data podle prahových hodnot, takže je nezajímá absolutní měřítko příznaků. Škálování je nutné pro modely založené na vzdálenostech (KNN, SVM) a pro modely s regularizací (logistická regrese, neuronové sítě).

Jak poznat, které příznaky jsou nejdůležitější?

Existuje několik přístupů a ideálně byste je měli kombinovat. Vzájemná informace (mutual information) měří statistickou závislost mezi příznakem a cílovou proměnnou. Feature importance ze stromových modelů ukazuje, jak často se příznak používá k dělení uzlů. A permutation importance měří pokles výkonu modelu, když se hodnoty příznaku náhodně zamíchají — tahle metoda je nejrobustnější, protože funguje s jakýmkoli modelem.

Lze feature engineering automatizovat?

Částečně ano. Knihovny jako Feature-engine (verze 1.9) nabízejí hotové transformátory kompatibilní se scikit-learn pipeline, které můžete skládat jako stavebnice. Pro automatické generování příznaků z relačních dat existuje Featuretools s jeho deep feature synthesis. Ale upřímně — automatizace nenahrazuje znalost domény. Nejlepší výsledky dostanete kombinací automatických nástrojů a ručně navržených příznaků na základě pochopení problému, který řešíte.