Optuna v Pythonu 2026: Ladění hyperparametrů ML modelů s Bayesovskou optimalizací

Aktualizováno: 8. července 2026

Optuna je open-source Python framework pro automatické ladění hyperparametrů, který používá Bayesovskou optimalizaci (algoritmus TPE) k tomu, aby v řádech desítek trialů našel lepší kombinaci parametrů, než jakou vyčerpávající GridSearchCV zvládne za stovky. V tomhle průvodci si projdeme workflow verze 4.9 z června 2026, ukážeme si samplery a prunery, integraci s XGBoost, LightGBM a scikit-learn a nasadíme Optuna Dashboard s LLM filtrováním trialů. Cílem je, abyste po přečtení uměli napsat produkční ladicí skript, který se dá spustit paralelně na více strojích.

Přiznám se, že jsem Optunu poprvé nasadil až loni, když nám v jednom projektu klasický RandomizedSearchCV ládl přes noc a stejně minul nejlepší okno pro learning_rate. Od té doby ji tahám do každého ML pipeline, a v následujících řádcích se snažím sepsat všechno, co bych si tenkrát přál vědět.

• Optuna 4.9.0 z 1. června 2026 přináší paralelizaci GPSampleru přes strategii Kriging Believer, plnou podporu AutoSampleru pro multi-objective úlohy a integraci s MLflow 3.0 přes třídu MlflowStorage.
• Základní workflow tvoří tři objekty: Trial (jeden pokus se sadou hyperparametrů), Study (kolekce trialů se stejným cílem) a objective funkce, která vrací skalární metriku k minimalizaci nebo maximalizaci.
• TPESampler je výchozí Bayesovský sampler. Pro paralelní běhy nebo malé rozpočty zvažte GPSampler, pro multi-objective NSGAIISampler a při pochybnostech použijte AutoSampler z OptunaHubu.
• HyperbandPruner v kombinaci s TPESamplerem podle benchmarků dominuje MedianPruneru. Po pár epochách zastaví neúspěšné trialy a ušetří GPU čas.
• Optuna se paralelizuje přes RDBStorage nebo JournalStorage. Spustíte stejný skript na N strojích a všechny trialy sdílejí historii přes SQLite či PostgreSQL bez zásahu do kódu.
• Pro produkční ML pipeline propojte Optunu se scikit-learn Pipeline, feature engineering krokem a nasazením přes FastAPI. Optuna ladí model, ale nezbavuje vás povinnosti mít reprodukovatelný preprocessing.

Co je Optuna a proč ji používat v roce 2026?

Optuna je hyperparametrický optimalizační framework s define-by-run API. Vytvořil ho tým japonské firmy Preferred Networks. Na rozdíl od klasického GridSearchCV ze scikit-learn nezkouší všechny kombinace, ale používá algoritmus TPE (Tree-structured Parzen Estimator), který se učí z předchozích trialů a soustředí se na oblasti hyperparametrického prostoru, kde model dosahuje lepší metriky. V praxi to znamená, že 50 trialů Optuny často porazí 500 trialů grid searche, a to při desetinovém času a bez ručního zužování mřížky.

Framework se v roce 2026 stal defacto standardem pro produkční ML pipeline. Podle repozitáře na GitHubu překročila Optuna 12 000 hvězdiček, integruje se se všemi mainstreamovými knihovnami (scikit-learn, PyTorch, TensorFlow, XGBoost, LightGBM, CatBoost) a má nativní podporu pro paralelizaci přes sdílené úložiště. Definice prostoru je jen běžný Python, takže můžete používat if, for, ba i vnořené modely, protože prostor se konstruuje dynamicky za běhu trialu.

Pokud v pipeline už používáte scikit-learn Pipeline pro preprocessing a modelování, Optuna zapadá přirozeně. Objective funkce dostane pipeline s parametrizovanými kroky, provede cross-validation a vrátí průměrné skóre. Model už není potřeba retrénovat mimo pipeline, takže leakage z preprocessingu do validačního foldu neprosákne.

Instalace Optuny a novinky verze 4.9

Optuna 4.9.0 vyšla 1. června 2026 a je to výchozí verze pro celé druhé pololetí. Vyžaduje Python 3.9 nebo novější (osobně doporučuju 3.12 kvůli výkonu asyncio). Z knihoven potřebuje jen alembic, colorlog, numpy, PyYAML, sqlalchemy a tqdm. Instalace probíhá klasicky přes pip, případně uv:

uv pip install "optuna==4.9.0" optuna-dashboard optuna-integration
# nebo klasicky
pip install "optuna==4.9.0" optuna-dashboard "optuna-integration[xgboost,lightgbm,sklearn]"

Co je ve verzi 4.9 nového?

Hlavní novinkou je paralelizace GPSampleru pomocí strategie Kriging Believer. Při paralelních trialech se GP surrogát dočasně doplňuje predikovanými hodnotami běžících trialů, takže se nové návrhy neopírají o zastaralou historii. Interně se navíc paralelně optimalizuje akviziční funkce přes PyTorch batching, což znamená až 4× rychlejší návrh nových kandidátů oproti verzi 4.7.

AutoSampler dostal plnou podporu pro multi-objective a constrained optimization. Dřív spadl na NSGA-II, dneska vybírá mezi TPE, GP, NSGA-II a HypE podle rozměru prostoru a počtu cílů. Do PedAnovaImportanceEvaluatoru přibyly parametry target_quantile a region_quantile, díky nimž lze zkoumat lokální důležitost hyperparametrů (například „které parametry hýbou skóre v horních 10 % trialů"). Na OptunaHubu přibyly samplery SPEA-II, HypE a Robust Bayesian Optimization pro úlohy s perturbacemi vstupů.

Základní workflow: objective, study a trial

Každý běh Optuny stojí na trojici pojmů. Trial reprezentuje jeden pokus s konkrétní sadou hyperparametrů. Study je kolekce trialů sdílející stejný cíl a směr optimalizace. Objective je Python funkce, která dostane objekt trial, uvnitř zavolá trial.suggest_* pro každý hyperparametr a vrátí skalární metriku, kterou má Optuna minimalizovat či maximalizovat. Nic víc, žádná dekorátorová magie.

Absolutní minimum, které v Optuně někdo napíše (najít minimum kvadratické funkce), vypadá takhle:

import optuna

def objective(trial: optuna.Trial) -> float:
    x = trial.suggest_float("x", -10.0, 10.0)
    return (x - 2.0) ** 2

study = optuna.create_study(direction="minimize")
study.optimize(objective, n_trials=100, show_progress_bar=True)

print(f"Nejlepší x: {study.best_params['x']:.4f}")
print(f"Hodnota:   {study.best_value:.6f}")

Metody suggest_* pokrývají všechny běžné typy hyperparametrů: suggest_float (spojitý interval, volitelně s log=True pro learning rate), suggest_int (celočíselné rozsahy), suggest_categorical (výběr ze seznamu) a rozšíření z OptunaHubu i suggest_datetime nebo dynamické podmíněné parametry. Jelikož jde o klasický Python, můžete uvnitř větvit:

def objective(trial):
    classifier = trial.suggest_categorical("clf", ["rf", "svm", "gbm"])
    if classifier == "rf":
        n_estimators = trial.suggest_int("rf_n_estimators", 50, 500, step=50)
        max_depth = trial.suggest_int("rf_max_depth", 3, 20)
    elif classifier == "svm":
        C = trial.suggest_float("svm_c", 1e-4, 1e2, log=True)
    else:
        lr = trial.suggest_float("gbm_lr", 1e-4, 3e-1, log=True)
    ...

V tom je hlavní síla define-by-run API. Nemusíte vypisovat kartézský součin všech kombinací dopředu, prostor se buduje za běhu podle rozhodnutí trialu.

Samplery: TPE, GPSampler a AutoSampler

Sampler je algoritmus, který rozhoduje, jaké hyperparametry navrhnout dalšímu trialu. Optuna v roce 2026 nabízí sedm zabudovaných samplerů a další v OptunaHubu.

TPESampler je výchozí a v tabularním ML téměř neomylný. Staví dvě density modely, jeden nad trialy s dobrými skóre (l(x)) a druhý nad špatnými (g(x)), a navrhuje kandidáty, kteří maximalizují poměr l(x)/g(x). Funguje s libovolnou kombinací spojitých, celočíselných a kategorických parametrů. Pokud chcete reprodukovatelnost, předejte seed:

from optuna.samplers import TPESampler
sampler = TPESampler(seed=42, multivariate=True, group=True)
study = optuna.create_study(direction="maximize", sampler=sampler)

Přepínač multivariate=True zapíná model, který zohledňuje závislosti mezi hyperparametry (třeba že learning_rate a n_estimators spolu koreluje), a group=True správně zachází s podmíněnými parametry z předchozí ukázky.

GPSampler se opírá o gaussovské procesy. Do 30 trialů obvykle vyhrává nad TPE, protože GP se učí z několika málo bodů, kdežto TPE potřebuje zhruba 20 startovacích trialů. Ve verzi 4.9 přišla Kriging Believer paralelizace, takže při n_jobs=8 už nedochází k tomu, že by pět workerů dostalo skoro stejný návrh. Používejte GPSampler pro drahé objective funkce (deep learning, velké tabulky) s malým rozpočtem trialů (do ~50).

AutoSampler (z optuna-hub) je nejrozumnější default pro rok 2026. Podle rozměru prostoru a typu úlohy (single/multi-objective, constrained) vybere sampler sám. Pro tým, který jen ladí modely a nechce studovat rozdíly mezi TPE a NSGA-II, je to plug-and-play řešení:

import optunahub
mod = optunahub.load_module("samplers/auto_sampler")
sampler = mod.AutoSampler()
study = optuna.create_study(sampler=sampler, direction="maximize")

Ostatní zajímavé samplery: CmaEsSampler pro spojité prostory s 30+ dimenzemi, NSGAIISampler a nový SPEAIISampler pro multi-objective, QMCSampler pro low-discrepancy prohledávání a RandomSampler jako baseline.

Prunery: MedianPruner, HyperbandPruner a včasné zastavení

Pruner sleduje průběžnou metriku uvnitř trialu (třeba loss po každé epoše nebo po každém boosting kroku) a rozhodne se, jestli trial předčasně ukončit. To je klíč k tomu, jak dostat z jedné GPU pětkrát víc trialů za stejný čas.

MedianPruner je nejpoužívanější. Zastaví trial, pokud je jeho průběžná metrika horší než medián všech předchozích trialů v témž kroku. Parametr n_startup_trials říká, kolik trialů se má doběhnout nedotčeně, aby byl medián reprezentativní.

HyperbandPruner podle benchmarků Optuny dominuje ve dvojici s TPESamplerem. Kombinuje successive halving s několika „brackets": rozdělí trialy do skupin s různým počátečním rozpočtem a agresivně odřeže neúspěšné. Pro deep learning je to defaultní volba:

from optuna.pruners import HyperbandPruner
study = optuna.create_study(
    direction="maximize",
    sampler=TPESampler(seed=42),
    pruner=HyperbandPruner(min_resource=1, max_resource=50, reduction_factor=3),
)

Pruning zapnete voláním trial.report(intermediate_value, step) uvnitř trénovací smyčky a kontrolou trial.should_prune():

def objective(trial):
    lr = trial.suggest_float("lr", 1e-4, 1e-1, log=True)
    model = build_model(lr)
    for epoch in range(50):
        train_one_epoch(model)
        val_acc = evaluate(model)
        trial.report(val_acc, epoch)
        if trial.should_prune():
            raise optuna.TrialPruned()
    return val_acc

Praktický příklad: ladění XGBoost s Optunou

Následující ukázka ladí XGBoost klasifikátor na datasetu breast_cancer, používá TPESampler s HyperbandPrunerem, cross-validation přes tři foldy a vrací průměr ROC AUC. Kód je připravený ke spuštění. Stačí Python 3.11+, optuna, xgboost>=2.1 a scikit-learn.

import numpy as np
import optuna
import xgboost as xgb
from optuna.integration import XGBoostPruningCallback
from optuna.pruners import HyperbandPruner
from optuna.samplers import TPESampler
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import StratifiedKFold

RANDOM_SEED = 42
X, y = load_breast_cancer(return_X_y=True)

def objective(trial: optuna.Trial) -> float:
    params = {
        "objective": "binary:logistic",
        "eval_metric": "auc",
        "booster": trial.suggest_categorical("booster", ["gbtree", "dart"]),
        "lambda": trial.suggest_float("lambda", 1e-8, 10.0, log=True),
        "alpha": trial.suggest_float("alpha", 1e-8, 10.0, log=True),
        "learning_rate": trial.suggest_float("lr", 1e-3, 3e-1, log=True),
        "max_depth": trial.suggest_int("max_depth", 3, 12),
        "subsample": trial.suggest_float("subsample", 0.5, 1.0),
        "colsample_bytree": trial.suggest_float("colsample_bytree", 0.5, 1.0),
        "min_child_weight": trial.suggest_int("min_child_weight", 1, 20),
        "tree_method": "hist",
        "seed": RANDOM_SEED,
    }
    if params["booster"] == "dart":
        params["rate_drop"] = trial.suggest_float("rate_drop", 1e-8, 1.0, log=True)

    scores = []
    skf = StratifiedKFold(n_splits=3, shuffle=True, random_state=RANDOM_SEED)
    for fold, (train_idx, val_idx) in enumerate(skf.split(X, y)):
        dtrain = xgb.DMatrix(X[train_idx], label=y[train_idx])
        dvalid = xgb.DMatrix(X[val_idx], label=y[val_idx])
        pruning_cb = XGBoostPruningCallback(trial, f"validation-auc")

        booster = xgb.train(
            params,
            dtrain,
            num_boost_round=500,
            evals=[(dvalid, "validation")],
            early_stopping_rounds=25,
            callbacks=[pruning_cb] if fold == 0 else [],
            verbose_eval=False,
        )
        preds = booster.predict(dvalid)
        auc = float(np.mean((preds > 0.5) == y[val_idx]))
        scores.append(auc)
    return float(np.mean(scores))

if __name__ == "__main__":
    study = optuna.create_study(
        study_name="xgb_breast_cancer",
        direction="maximize",
        sampler=TPESampler(seed=RANDOM_SEED, multivariate=True),
        pruner=HyperbandPruner(min_resource=10, max_resource=500, reduction_factor=3),
        storage="sqlite:///optuna_studies.db",
        load_if_exists=True,
    )
    study.optimize(objective, n_trials=100, show_progress_bar=True, n_jobs=1)
    print("Nejlepší parametry:", study.best_params)
    print(f"Nejlepší ROC AUC:  {study.best_value:.4f}")

Všimněte si detailů, které jsou v produkčním kódu důležité. storage="sqlite:///..." ukládá všechny trialy na disk, takže studii lze pozastavit a pokračovat. load_if_exists=True pak druhý běh navazuje na první. Podmíněný parametr rate_drop se navrhne jen pro dart booster. Pruning callback se aktivuje pouze pro první fold; kdyby se aktivoval pro všechny, mohlo by dojít k předčasnému zastavení kvůli šumu jednoho z foldů. (Na tenhle detail jsem přišel, až když se mi studie začala „mrzačit" po padesáti trialech a nejlepší modely končily prořezané.)

Ladění LightGBM a integrace s populárními knihovnami

LightGBM má v optuna-integration dvě cesty: buď obecný LightGBMPruningCallback, nebo speciální LightGBMTuner, který ladí sedm nejdůležitějších parametrů (lambda_l1, lambda_l2, num_leaves, feature_fraction, bagging_fraction, bagging_freq, min_child_samples) v přednastaveném pořadí. Pro rychlé PoC LightGBMTuner úplně stačí:

import lightgbm as lgb
from optuna.integration.lightgbm import LightGBMTuner
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

X, y = load_breast_cancer(return_X_y=True)
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
dtrain = lgb.Dataset(X_train, label=y_train)
dval = lgb.Dataset(X_val, label=y_val, reference=dtrain)

params = {"objective": "binary", "metric": "binary_logloss", "verbosity": -1}
tuner = LightGBMTuner(
    params, dtrain, valid_sets=[dval],
    num_boost_round=1000, callbacks=[lgb.early_stopping(50)],
)
tuner.run()
print("Best score:", tuner.best_score)
print("Best params:", tuner.best_params)

Pokud potřebujete jemnější kontrolu (třeba prohledávat i learning_rate nebo max_bin), napište vlastní objective a použijte LightGBMPruningCallback. Postup je identický jako u XGBoostu z předchozí kapitoly. Integrace Optuny pokrývá i PyTorch Lightning, Keras/TensorFlow, FastAI, MLflow, Weights & Biases, Ray Tune a scikit-learn, a seznam roste každý release.

Když už jste v produkci a máte natrénovaný model, další krok je nasazení. Pro rychlé REST API se hodí Nasazení ML modelů s FastAPI 2026, kde ukazujeme, jak nejlepší studii z Optuny přímo napojit na inference endpoint a verzovat modely.

Vícecílová optimalizace a Pareto fronta

V reálných úlohách málokdy optimalizujete jednu metriku. Chcete zároveň vysoké ROC AUC a nízkou inferenční latenci, případně nízkou spotřebu paměti. Optuna to řeší nativně:

def objective(trial):
    n_estimators = trial.suggest_int("n_estimators", 50, 1000)
    max_depth = trial.suggest_int("max_depth", 3, 15)
    model = train_rf(n_estimators, max_depth)
    accuracy = evaluate_accuracy(model)
    latency_ms = measure_latency(model)
    return accuracy, latency_ms

study = optuna.create_study(
    directions=["maximize", "minimize"],
    sampler=optuna.samplers.NSGAIISampler(seed=42),
)
study.optimize(objective, n_trials=200)

for trial in study.best_trials:
    print(trial.values, trial.params)

study.best_trials vrátí Pareto frontu, tedy množinu řešení, kde už nejde jednu metriku vylepšit bez zhoršení druhé. Vy pak jako datový vědec vyberete bod, který odpovídá SLA na latenci (třeba „latence pod 20 ms a mezi tím nejvyšší accuracy"). Ve verzi 4.9 AutoSampler tuto úlohu detekuje a automaticky přepne na NSGA-II či HypE, aniž byste sampler explicitně nastavovali.

Jak spouštět Optunu paralelně a distribuovaně?

Optuna nabízí tři úrovně paralelizace. V rámci jednoho procesu předáte n_jobs:

study.optimize(objective, n_trials=200, n_jobs=4)

Optuna spustí čtyři vlákna, ale kvůli GIL to má smysl jen pokud objective funkce sama volá C/BLAS operace (XGBoost, sklearn s n_jobs=1). Na jednom stroji přes procesy použijte sdílené SQLite úložiště a spusťte skript vícekrát z shellu:

# Terminál 1
python optimize.py &
# Terminál 2
python optimize.py &
# Terminál 3
python optimize.py

Podmínkou je, že create_study volá storage="sqlite:///optuna_studies.db" a load_if_exists=True. Napříč více stroji vyměňte SQLite za PostgreSQL nebo MySQL, například storage="postgresql://user:pw@host/optuna", nebo použijte JournalStorage s NFS. Verze 4.9 přidala varování, když JournalStorage nemůže získat zámek delší dobu, což pomůže diagnostikovat pomalé sdílené filesystemy.

Optuna Dashboard, vizualizace a MLflow 3.0

Optuna Dashboard v0.20.0 (červen 2026) je webové UI, kde vidíte v reálném čase historii optimalizace, důležitost hyperparametrů, paralelní souřadnicové grafy a contour ploty. Spuštění je triviální:

optuna-dashboard sqlite:///optuna_studies.db --port 8080

Novinkou 0.20 je LLM integrace. V panelu můžete napsat „ukaž mi trialy, kde je max_depth vyšší než 8 a AUC nad 0.95", a dashboard sám dotaz převede na filtr a vygeneruje Plotly graf. Alternativou jsou vestavěné vizualizace v optuna.visualization, které vrací Plotly figury a hodí se do notebooků:

from optuna.visualization import (
    plot_optimization_history,
    plot_param_importances,
    plot_parallel_coordinate,
)

plot_optimization_history(study).show()
plot_param_importances(study).show()
plot_parallel_coordinate(study, params=["lr", "max_depth", "subsample"]).show()

Pro produkční ML platformy nabízí Optuna 4.9 novou třídu MlflowStorage. Trialy se ukládají přímo do MLflow Tracking Serveru, takže máte celou historii experimentů v jednom nástroji. V kombinaci s třídou MlflowSparkStudy můžete spustit tisíce trialů paralelně přes PySpark executory. Pokud si výsledky pak vizualizujete dále v notebooku, hodí se náš průvodce vizualizací dat v Pythonu.

Optuna vs GridSearchCV vs RandomizedSearchCV

Datoví vědci se pravidelně ptají, kdy Optunu nepoužívat, když má scikit-learn na kolo GridSearchCV a RandomizedSearchCV jen import navíc. Následující tabulka shrnuje, kdy sáhnout po čem.

Vlastnost	GridSearchCV	RandomizedSearchCV	Optuna (TPE)
Strategie prohledávání	Vyčerpávající	Náhodné vzorky	Bayesovská (TPE/GP)
Efektivita při 5+ parametrech	Nízká	Střední	Vysoká
Podmíněné parametry	Neumí	Neumí	Nativně (define-by-run)
Předčasné zastavení trialu	Ne	Ne	Ano (pruners)
Distribuce mezi stroji	Ne	Ne	Ano (RDB/JournalStorage)
Multi-objective	Ne	Ne	Ano (NSGA-II, HypE)
Podpora knihoven	scikit-learn	scikit-learn	sklearn, XGBoost, LightGBM, PyTorch, Keras…
Křivka učení	Nízká	Nízká	Střední
Reprodukovatelnost	Plná	Se random_state	Se seed, sekvenční běh

Praktické pravidlo: pokud máte tři a méně parametrů s malým počtem hodnot a levnou objective funkci, GridSearchCV ušetří čas na code review. Ve všech ostatních případech je Optuna produktivnější a levnější. V experimentech z Machine Learning Mastery Optuna dorovnává gridsearch skóre při 5 až 10× menším počtu trialů. Než ladíte model, ujistěte se, že máte kvalitní vstupy. Náš průvodce feature engineeringem v Pythonu vysvětluje, proč sebelepší hyperparametry nezachrání špatné příznaky.

Časté problémy a jak je řešit

„Study konverguje na okraj intervalu." Optuna hlásí, že nejlepší lr = 3e-1, a to je horní hranice. Rozšiřte prostor a nechte doběhnout dalších 30 trialů. Pokud znovu narazí na okraj, rozšiřte znovu; konvergence na hranu je signál, že jste rozsah zvolili moc úzce.

„Trialy jsou pomalé, nedokážu spustit dost." Zapněte pruner, nasaďte tree_method="hist" u XGBoostu, zmenšete num_boost_round na první průzkum a teprve po vyladění spusťte long run. Alternativou je ladit na 20% subsetu dat a finální model pak přetrénovat na plné datové sadě.

„Storage se zamyká." SQLite není optimalizované pro paralelní zápisy. Nad tři procesy přejděte na PostgreSQL/MySQL nebo na JournalStorage s pravidelně otevíraným zámkem.

„Objective vrací NaN." V takovém případě vyhoďte optuna.TrialPruned() nebo výjimku. Optuna trial označí jako failed a nezanese ho do modelu sampleru. Nikdy nevracejte NaN, poškozuje to Bayesovský model.

„Chci trvale zafixovat část parametrů." Použijte study.enqueue_trial({"lr": 0.05, ...}) pro warm-start s ručně nadefinovanými hodnotami nebo optuna.trial.FixedTrial pro reprodukování konkrétního trialu.

Nejčastější dotazy

Jak nainstalovat Optuna v Pythonu?

Nainstalujte pip install "optuna==4.9.0" optuna-dashboard "optuna-integration[xgboost,lightgbm,sklearn]". Verze 4.9.0 vyšla 1. června 2026 a vyžaduje Python 3.9 nebo novější; k základnímu běhu stačí NumPy, SQLAlchemy a Alembic, které se doinstalují automaticky.

Je Optuna lepší než GridSearchCV?

Ano, ve většině reálných úloh. TPE sampler Optuny se učí z historie trialů a soustředí prohledávání na slibné oblasti, takže při 5 až 10× méně trialech dosáhne stejného skóre jako vyčerpávající grid search. GridSearchCV má smysl už jen pro velmi malé prostory s třemi či méně parametry.

Jak spouštět Optunu paralelně na více strojích?

Nastavte sdílené úložiště, například PostgreSQL: optuna.create_study(storage="postgresql://user:pw@host/db", load_if_exists=True). Spusťte stejný skript na libovolném počtu strojů a všechny trialy budou sdílet historii sampleru. Pro pár procesů na jednom stroji stačí sqlite:///study.db.

Který sampler v Optuně použít?

V roce 2026 začněte s AutoSamplerem z OptunaHubu, který sampler vybere za vás. Pro nízko-rozpočtové úlohy (do 50 trialů) je nejlepší GPSampler, pro tabularní ML se stovkami trialů TPESampler, a pro multi-objective NSGA-II nebo HypE. RandomSampler nechte jako baseline.

Jak vizualizovat výsledky studie?

Nejrychlejší je spustit optuna-dashboard sqlite:///optuna_studies.db, což otevře webové UI s optimalizační historií, důležitostí parametrů a paralelními souřadnicovými grafy. Alternativně použijte optuna.visualization.plot_optimization_history(study).show() přímo v Jupyteru pro Plotly figury.

Jak Optuna spolupracuje s MLflow?

Od verze 4.9 lze místo SQLite/Postgres použít MlflowStorage, které ukládá trialy přímo do MLflow Tracking Serveru. Třída MlflowSparkStudy pak spustí paralelní studii přes PySpark executory, takže dostanete jednotné rozhraní pro experimenty i ladění hyperparametrů.