כוונון היפרפרמטרים בפייתון עם Optuna 4: מדריך מעשי לשנת 2026

עודכן: 14 ביולי, 2026

כוונון היפרפרמטרים בפייתון עם Optuna הוא תהליך של חיפוש אוטומטי אחר ערכי ההיפרפרמטרים האופטימליים למודל למידת מכונה, באמצעות אלגוריתם Bayesian Optimization (בעיקר TPE, קרי Tree-structured Parzen Estimator) שמתמקד באזורי המרחב המבטיחים ביותר במקום לסרוק כל צירוף אפשרי. בגרסה 4.x, ששוחררה במחצית 2026, Optuna הפכה לספריית ברירת המחדל של רוב חוקרי הנתונים בזכות ה־API הפייתוני שלה, יכולות ה־Pruning, והוויזואליזציה המובנית. במדריך הזה אני מציגה זרימת עבודה מלאה, מהתקנה ועד אופטימיזציה מבוזרת, עם קוד רץ שבדקתי בעצמי על פרויקטים אמיתיים.

• Optuna 4 משתמשת באלגוריתם TPE (Tree-structured Parzen Estimator) שמאפשר להגיע לתוצאות טובות יותר מ־GridSearchCV ב־30%–50% פחות ניסויים במרחב חיפוש טיפוסי.
• מבנה ה־Trial וה־Study מאפשר להגדיר מרחב חיפוש דינמי (Define-by-Run) שתומך גם בהיפרפרמטרים מותנים, יתרון משמעותי על פני scikit-learn.
• Pruners כמו MedianPruner ו־HyperbandPruner מקצרים את זמן האופטימיזציה ב־40%–70% על ידי עצירה מוקדמת של ניסויים חלשים.
• Optuna משתלבת ישירות עם scikit-learn, XGBoost, LightGBM, PyTorch ו־Keras, וכוללת callbacks מותאמים לכל אחת מהן.
• אופטימיזציה מרובת מטרות (Multi-objective) מחזירה חזית פארטו במקום פתרון בודד, שימושי כשמשקללים דיוק מול זמן חיזוי.
• מודול optuna.visualization מייצר תרשימי Plotly אינטראקטיביים לניתוח החשיבות של כל היפרפרמטר ולהבנת מסלול החיפוש.

מה זה Optuna ולמה משתמשים בו?

Optuna היא ספריית קוד־פתוח של Preferred Networks לאופטימיזציית היפרפרמטרים, שפורסמה לראשונה ב־2019 והגיעה לגרסת LTS 4.0 ביוני 2026. בניגוד לגישה הקלאסית של Grid Search, שבודקת כל צירוף במרחב סופי מוגדר מראש, Optuna מפעילה אופטימיזציה אדפטיבית: בכל ניסוי (trial) היא לומדת מהתוצאות הקודמות ומעדיפה אזורים במרחב ההיפרפרמטרים שהניבו ביצועים טובים.

הגישה הזו נקראת Bayesian Optimization, והמאמר הבסיסי של Bergstra ו־Bengio מ־2011 ("Algorithms for Hyper-Parameter Optimization", NeurIPS) הוכיח מתמטית שלמרחב חיפוש טיפוסי של מודל למידה עמוקה, כמות ניסויים אקראית קטנה יכולה להתעלות על סריקת רשת שוות־עלות ב־30%–50%. Optuna לוקחת את הרעיון הזה צעד קדימה עם TPE.

שלושה יתרונות מבחינים אותה במיוחד. ראשית, ה־API מוגדר בזמן ריצה (Define-by-Run). מרחב החיפוש נבנה בתוך פונקציית ה־objective עצמה, כך שתוכלו לתלות היפרפרמטר אחד באחר (למשל, עומק העץ תלוי בסוג המודל). שנית, מנגנון Pruning עוצר ניסויים חלשים באמצע האימון. שלישית, אחסון קבוע (RDB או Journal) שמאפשר חזרה לניסוי שהופסק. זה קריטי לריצות ארוכות של ימים.

בעבודתי היומיומית אני משתמשת ב־Optuna לכל פרויקט טאבולרי (XGBoost, LightGBM, CatBoost), וכשמדובר במודלים עמוקים אני מחברת אותה ל־PyTorch Lightning. אם אתם מגיעים מרקע של בניית מודל סיווג בפייתון עם scikit-learn, המעבר ל־Optuna יקצר לכם את זמן ההגעה למודל מייצור בשעות עבודה. אני נתקלתי בזה בעצמי בפרויקט קרדיט־סקורינג אחרון, שבו GridSearch רץ יומיים שלמים על השרת. עברנו ל־Optuna והגענו לתוצאה טובה יותר תוך שבע שעות בלבד.

Optuna לעומת GridSearchCV ו־RandomizedSearchCV

לפני שנצלול לקוד, כדאי להבין מתי Optuna מכה את הכלים המובנים של scikit-learn ומתי לא. השאלה הזו עולה כמעט בכל שיחת ייעוץ שלי, אז הכנתי טבלת השוואה תמציתית:

מאפיין	GridSearchCV	RandomizedSearchCV	Optuna 4
אסטרטגיית חיפוש	סריקה ממצה	דגימה אקראית	Bayesian (TPE, CMA-ES, NSGA-II)
מרחב חיפוש דינמי	לא	לא	כן (Define-by-Run)
Pruning של ניסויים חלשים	לא	לא	כן (Median, Hyperband, SHA)
אחסון קבוע והמשך ריצה	לא	לא	כן (SQLite, PostgreSQL, JournalStorage)
אופטימיזציה מרובת מטרות	לא	לא	כן (חזית פארטו)
ניסויים לפתרון טוב	גבוה מאוד	בינוני	נמוך
עקומת למידה	קלה	קלה	בינונית

הכלל שלי: אם מרחב החיפוש שלכם קטן מ־50 צירופים ואתם עובדים על מודל קליל (רגרסיה לוגיסטית, KNN), GridSearchCV יספיק ואפילו יעיל יותר בגלל פשטותו. ברגע שאתם עוברים ל־XGBoost/LightGBM עם 5–8 היפרפרמטרים רציפים, Optuna תחסוך שעות. ל־RandomizedSearchCV אין כמעט מקרה שימוש שבו Optuna לא עדיפה, פשוט הפעילו TPESampler.

הבדל חשוב שרבים מפספסים: Optuna אינה מבצעת עבורכם Cross-Validation. אתם צריכים לקרוא ל־cross_val_score בתוך פונקציית ה־objective ולהחזיר את הממוצע. זה נותן שליטה (למשל להשתמש ב־StratifiedKFold מותאם), אבל דורש קוד מפורש.

התקנה של Optuna 4 והפעלה ראשונית

Optuna 4 דורשת Python 3.10 ומעלה, וממליצה על 3.12 עבור ביצועי Sampler מיטביים. ההתקנה בסיסית:

pip install optuna==4.0.0 optuna-integration scikit-learn==1.8 xgboost==2.2 plotly==5.24

אם אתם עובדים ב־Jupyter Notebook (ואני ממליצה, הוויזואליזציות אינטראקטיביות במיוחד שם), הוסיפו גם:

pip install "notebook>=7.2" ipywidgets nbformat

הבדיקה הקצרה ביותר שאני מפעילה כדי לוודא שההתקנה תקינה היא אופטימיזציה של פונקציה קמורה טריוויאלית. אם היא לא מתכנסת ל־0 תוך 20 ניסויים, יש בעיה בגרסת NumPy:

import optuna

def objective(trial):
    x = trial.suggest_float("x", -10, 10)
    return (x - 2) ** 2

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

print(f"Best x: {study.best_params['x']:.4f}")
print(f"Best value: {study.best_value:.6f}")

הפלט הצפוי הוא x קרוב מאוד ל־2 ו־value קרוב ל־0. שימו לב לפרמטר show_progress_bar. הוא מציג בר התקדמות של tqdm, שימושי במיוחד לניסויים ארוכים.

אזהרה קטנה על סביבת Conda: אם אתם עובדים עם conda-forge, ודאו שאתם מתקינים את optuna-dashboard בנפרד, כי הוא לא נכלל ב־meta package הבסיסי. הדשבורד הוא כלי חובה למי שמריץ ריצות ארוכות ורוצה לעקוב מהדפדפן. תיעוד ההתקנה הרשמי מופיע באתר הפרויקט של Optuna, למקרה שאתם רוצים לוודא תאימות עם סביבה ספציפית.

מבנה בסיסי: Study, Trial ופונקציית Objective

ההבנה של שלושת המושגים האלה היא המפתח לעבודה אפקטיבית עם Optuna. Study הוא אובייקט על־רמה שמייצג את כל תהליך האופטימיזציה. הוא מכיל היסטוריה, הגדרות sampler ו־pruner, ואת החיבור לאחסון. Trial הוא ניסוי בודד, אובייקט שנוצר בכל קריאה לפונקציית ה־objective ומאפשר לדגום ערכים. Objective היא פונקציית פייתון שמקבלת trial ומחזירה ערך מטרי אחד (או מספר, לאופטימיזציה מרובת מטרות).

הנה דוגמה מלאה על מערך הנתונים Breast Cancer של scikit-learn, עם RandomForest כמודל:

import optuna
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score, StratifiedKFold

X, y = load_breast_cancer(return_X_y=True)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

def objective(trial):
    # Define search space inside the objective
    n_estimators = trial.suggest_int("n_estimators", 100, 800, step=50)
    max_depth = trial.suggest_int("max_depth", 3, 25)
    min_samples_split = trial.suggest_int("min_samples_split", 2, 20)
    min_samples_leaf = trial.suggest_int("min_samples_leaf", 1, 10)
    max_features = trial.suggest_categorical(
        "max_features", ["sqrt", "log2", 0.5, 0.8]
    )
    criterion = trial.suggest_categorical(
        "criterion", ["gini", "entropy", "log_loss"]
    )

    clf = RandomForestClassifier(
        n_estimators=n_estimators,
        max_depth=max_depth,
        min_samples_split=min_samples_split,
        min_samples_leaf=min_samples_leaf,
        max_features=max_features,
        criterion=criterion,
        random_state=42,
        n_jobs=-1,
    )

    score = cross_val_score(clf, X, y, cv=cv, scoring="roc_auc", n_jobs=-1)
    return score.mean()

study = optuna.create_study(
    direction="maximize",
    study_name="rf-breast-cancer",
    sampler=optuna.samplers.TPESampler(seed=42, n_startup_trials=10),
)
study.optimize(objective, n_trials=100, timeout=900)

print(f"Best ROC-AUC: {study.best_value:.4f}")
print("Best hyperparameters:")
for k, v in study.best_params.items():
    print(f"  {k}: {v}")

שימו לב לפרמטר n_startup_trials=10 ב־TPESampler. במהלך עשרת הניסויים הראשונים, Optuna דוגמת אקראית. היא זקוקה לכמות מינימלית של תצפיות כדי לבנות מודל הסתברותי משמעותי. עם פחות מכך, ה־TPE מתנהג כמו RandomizedSearch רגיל אבל עם overhead מיותר.

אני ממליצה תמיד להגדיר study_name ו־storage. גם אם אתם ריצים לוקאלית, אחסון SQLite הופך את הריצה לניתנת לשחזור: storage="sqlite:///optuna_studies.db". אחרי הריצה תוכלו לפתוח דשבורד עם optuna-dashboard sqlite:///optuna_studies.db.

כיצד עובד אלגוריתם TPE מאחורי הקלעים

אלגוריתם ה־Tree-structured Parzen Estimator, שהוצג לראשונה ב־2011 (Bergstra et al., NIPS 2011), הוא לב הלב של Optuna. הבנה מוצקה של הדרך שבה הוא בוחר את הניסוי הבא הכרחית כדי להגדיר מרחב חיפוש טוב. אני אסביר בצורה מפושטת אבל מדויקת.

בכל שלב באופטימיזציה, TPE מחלק את כל הניסויים הקיימים לשתי קבוצות: l(x), הצפיפות של ההיפרפרמטרים בין הניסויים הטובים ביותר (בברירת מחדל, ה־10% העליונים), ו־g(x), הצפיפות בין הניסויים האחרים. אחר כך הוא דוגם ניסוי חדש שממקסם את היחס l(x)/g(x). במילים אחרות: הוא בוחר נקודה במרחב שסביר יותר להיות טובה מאשר בינונית.

המבנה ה"עצי" (tree-structured) בשם רומז ליכולת של TPE להתמודד עם היפרפרמטרים מותנים. לדוגמה, אם אתם מכוונים גם את סוג המודל וגם היפרפרמטרים ספציפיים לכל סוג, TPE יבין את המבנה ההיררכי:

from sklearn.svm import SVC
from xgboost import XGBClassifier

def objective(trial):
    classifier = trial.suggest_categorical(
        "classifier", ["rf", "svm", "xgb"]
    )
    if classifier == "rf":
        n_estimators = trial.suggest_int("rf_n_estimators", 50, 500)
        max_depth = trial.suggest_int("rf_max_depth", 3, 20)
        model = RandomForestClassifier(
            n_estimators=n_estimators, max_depth=max_depth, random_state=42
        )
    elif classifier == "svm":
        C = trial.suggest_float("svm_C", 1e-3, 1e3, log=True)
        gamma = trial.suggest_float("svm_gamma", 1e-4, 1e1, log=True)
        model = SVC(C=C, gamma=gamma, random_state=42)
    else:  # xgb
        lr = trial.suggest_float("xgb_lr", 1e-3, 0.3, log=True)
        max_depth = trial.suggest_int("xgb_max_depth", 3, 12)
        model = XGBClassifier(
            learning_rate=lr, max_depth=max_depth, random_state=42
        )

    return cross_val_score(model, X, y, cv=5, scoring="accuracy").mean()

לגבי log=True ב־suggest_float: השתמשו בו לכל היפרפרמטר שמשתרע על סקאלה של סדרי גודל (learning rate, regularization). המרחב יידגם בסקאלה לוגריתמית, מה שמונע הטיה לכיוון הערכים הגדולים.

ב־Optuna 4 קיימים גם samplers מתקדמים יותר: CmaEsSampler למרחבים רציפים גבוהי־ממד (טוב מ־TPE במעל 50 היפרפרמטרים), ו־NSGAIISampler לאופטימיזציה מרובת מטרות. ברוב מקרי השימוש הטאבולריים, TPE הוא הבחירה הנכונה.

גיזום ניסויים (Pruning) לחיסכון בזמן חישוב

Pruning הוא הפיצ'ר שהופך את Optuna לחיסכון זמן דרמטי, ובכל זאת נשאר לא מנוצל אצל רוב המשתמשים. הרעיון: אם ניסוי מסוים נראה עצוב כבר אחרי חלק קטן מהאימון (למשל אחרי 3 epochs מתוך 100, או אחרי 2 folds מתוך 10), אין טעם להשלים אותו. Optuna תעצור אותו ותעבור לניסוי הבא.

הנה דוגמה עם LightGBM וכפיל cross-validation ידני שמדווח על ביניים:

import optuna
import lightgbm as lgb
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import roc_auc_score

X, y = load_breast_cancer(return_X_y=True)

def objective(trial):
    params = {
        "objective": "binary",
        "metric": "auc",
        "verbosity": -1,
        "boosting_type": "gbdt",
        "learning_rate": trial.suggest_float("lr", 0.01, 0.3, log=True),
        "num_leaves": trial.suggest_int("num_leaves", 15, 255),
        "feature_fraction": trial.suggest_float("ff", 0.5, 1.0),
        "bagging_fraction": trial.suggest_float("bf", 0.5, 1.0),
        "bagging_freq": trial.suggest_int("bfq", 1, 7),
        "min_child_samples": trial.suggest_int("mcs", 5, 100),
    }

    cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
    scores = []
    for step, (train_idx, val_idx) in enumerate(cv.split(X, y)):
        dtrain = lgb.Dataset(X[train_idx], y[train_idx])
        dval = lgb.Dataset(X[val_idx], y[val_idx])
        model = lgb.train(
            params, dtrain, num_boost_round=500,
            valid_sets=[dval], callbacks=[lgb.early_stopping(20)],
        )
        preds = model.predict(X[val_idx])
        auc = roc_auc_score(y[val_idx], preds)
        scores.append(auc)

        # Report intermediate score after each fold
        trial.report(np.mean(scores), step)
        if trial.should_prune():
            raise optuna.TrialPruned()

    return np.mean(scores)

study = optuna.create_study(
    direction="maximize",
    sampler=optuna.samplers.TPESampler(seed=42),
    pruner=optuna.pruners.MedianPruner(
        n_startup_trials=10, n_warmup_steps=2
    ),
)
study.optimize(objective, n_trials=200, timeout=1200)

ה־MedianPruner קוטע ניסוי אם הציון בשלב הביניים גרוע מהחציון של כל הניסויים בשלב זהה. HyperbandPruner אגרסיבי יותר ומבוסס על אלגוריתם Successive Halving, ומומלץ לאימונים ארוכים במיוחד (למידה עמוקה).

אינטגרציה עם scikit-learn ו־XGBoost

ל־Optuna חבילת עזר בשם optuna-integration שמוסיפה עטיפות רשמיות לספריות פופולריות. עבור XGBoost, השילוב הוא כמעט חד־שורתי:

from optuna.integration import XGBoostPruningCallback
import xgboost as xgb
from sklearn.metrics import roc_auc_score

def objective(trial):
    params = {
        "objective": "binary:logistic",
        "eval_metric": "auc",
        "learning_rate": trial.suggest_float("lr", 1e-3, 0.3, 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("cs", 0.5, 1.0),
        "reg_alpha": trial.suggest_float("alpha", 1e-8, 10.0, log=True),
        "reg_lambda": trial.suggest_float("lambda", 1e-8, 10.0, log=True),
    }
    dtrain = xgb.DMatrix(X_train, label=y_train)
    dval = xgb.DMatrix(X_val, label=y_val)

    pruning = XGBoostPruningCallback(trial, "validation-auc")
    booster = xgb.train(
        params, dtrain, num_boost_round=1000,
        evals=[(dval, "validation")],
        callbacks=[pruning], verbose_eval=False,
    )
    preds = booster.predict(dval)
    return roc_auc_score(y_val, preds)

עבור scikit-learn, אני ממליצה על אחת משתי גישות. הראשונה, קלאסית, קריאה ידנית ל־cross_val_score בתוך ה־objective, כמו שהראיתי בסעיף Study/Trial. השנייה מנצלת את optuna.integration.OptunaSearchCV, שמחקה את ה־API של GridSearchCV אבל משתמשת בסמפלר של Optuna מאחורי הקלעים:

from optuna.integration import OptunaSearchCV
from optuna.distributions import IntDistribution, FloatDistribution

param_distributions = {
    "n_estimators": IntDistribution(50, 500),
    "max_depth": IntDistribution(3, 20),
    "min_samples_split": IntDistribution(2, 20),
    "max_features": FloatDistribution(0.1, 1.0),
}

search = OptunaSearchCV(
    RandomForestClassifier(random_state=42),
    param_distributions,
    n_trials=100,
    cv=5,
    scoring="roc_auc",
    random_state=42,
)
search.fit(X, y)
print(f"Best score: {search.best_score_:.4f}")

הגישה הזו מצוינת כשאתם עוברים קוד קיים מ־GridSearchCV ל־Optuna: השינוי הוא בעיקר בייבוא. אם אתם רוצים להעמיק, המאמר שלי על הנדסת פיצ'רים בפייתון עם pandas ו־scikit-learn מראה איך לשלב Optuna עם Pipeline כדי לבצע אופטימיזציה משותפת של טרנספורמציות ומודל.

אופטימיזציה מרובת מטרות עם חזית פארטו

בפרויקטים אמיתיים, לעיתים רחוקות אנחנו מכווננים לדיוק בלבד. מודל שמדויק ב־95% אבל דורש 200ms חיזוי אינו רלוונטי במערכת בזמן אמת. Optuna תומכת באופטימיזציה מרובת מטרות באמצעות סמפלר NSGA-II (הרחבה לאלגוריתם גנטי), ומחזירה חזית פארטו, קרי קבוצת הפתרונות הלא־נשלטים.

import time
import lightgbm as lgb
from sklearn.metrics import roc_auc_score

def objective(trial):
    params = {
        "objective": "binary", "metric": "auc", "verbosity": -1,
        "num_leaves": trial.suggest_int("num_leaves", 15, 511),
        "learning_rate": trial.suggest_float("lr", 0.01, 0.3, log=True),
        "n_estimators": trial.suggest_int("n_est", 50, 1000),
    }
    dtrain = lgb.Dataset(X_train, y_train)
    model = lgb.train(params, dtrain, num_boost_round=params["n_estimators"])

    # Objective 1: accuracy (maximize)
    auc = roc_auc_score(y_val, model.predict(X_val))

    # Objective 2: prediction latency (minimize)
    start = time.perf_counter()
    for _ in range(100):
        model.predict(X_val[:1])
    latency_ms = (time.perf_counter() - start) * 10  # per prediction, ms

    return auc, latency_ms

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

# Pareto front trials
print(f"Number of Pareto-optimal trials: {len(study.best_trials)}")
for t in study.best_trials:
    print(f"AUC={t.values[0]:.4f}, Latency={t.values[1]:.2f}ms, "
          f"params={t.params}")

שימו לב לשינוי מ־direction יחיד ל־directions ברבים, ולשימוש ב־study.best_trials (רבים) במקום study.best_trial. הבחירה איזה טרייל להעביר לייצור היא החלטה עסקית. Optuna מספקת רק את קבוצת פארטו.

לניתוח החזית עצמה, השתמשו ב־optuna.visualization.plot_pareto_front(study) שמפיק תרשים אינטראקטיבי של שתי המטרות עם הצבעה על הנקודות הפרטיות. הודות לפורמט הזה, קל להציג את הטריידאוף למחזיקי עניין לא־טכניים בישיבת מוצר.

ויזואליזציה של תוצאות האופטימיזציה

אחרי ריצה של 100+ ניסויים, נתונים גולמיים לא יעזרו לכם להבין מה קרה. Optuna מספקת שש פונקציות ויזואליזציה עיקריות שכולן מבוססות על Plotly:

• plot_optimization_history(study): התכנסות הערך הטוב ביותר לאורך הניסויים. אם הגרף שטוח מוקדם, הסמפלר "תקוע" ואולי צריך להרחיב את מרחב החיפוש.
• plot_param_importances(study): חשיבות יחסית של כל היפרפרמטר, מבוססת על fANOVA. שימושי כדי לזהות פרמטרים לא רלוונטיים ולצמצם את המרחב בריצה הבאה.
• plot_slice(study): הקשר בין כל היפרפרמטר בודד לציון, עוזר לזהות ערכים לא רגישים.
• plot_contour(study, params=["lr", "max_depth"]): מפת חום דו־ממדית של שני היפרפרמטרים, מגלה אינטראקציות.
• plot_parallel_coordinate(study): כל טרייל כקו שעובר בין ההיפרפרמטרים, מדגיש דפוסים בטריילים המצליחים.
• plot_edf(study): Empirical Distribution Function של הציונים, כלי לניתוח יציבות הסמפלר.

import optuna.visualization as vis

fig1 = vis.plot_optimization_history(study)
fig1.show()

fig2 = vis.plot_param_importances(study)
fig2.show()

fig3 = vis.plot_contour(study, params=["learning_rate", "max_depth"])
fig3.show()

למי שעובד ב־Jupyter, שלוש שורות הקוד האלה מייצרות מיד תרשימים אינטראקטיביים. למי שרוצה דשבורד מתחדש בזמן אמת, optuna-dashboard הוא כלי חובה. הפעילו אותו בטרמינל נפרד בזמן שהאופטימיזציה רצה. עיינו במודול הוויזואליזציה הרשמי של Optuna לרשימה מלאה של פונקציות עזר.

אופטימיזציה מבוזרת ושמירת מצב

כשמדובר במאות ניסויים של XGBoost על מיליוני שורות, ריצה במחשב יחיד לא מספיקה. Optuna תומכת בביזור נטיבי דרך אחסון משותף. הרעיון פשוט: כל worker מפעיל את אותה פונקציית objective מול אותו study_name, ו־Optuna מסנכרנת את הניסויים דרך ה־RDB.

# worker.py — run on each machine
import optuna

study = optuna.load_study(
    study_name="xgb-large-scale",
    storage="postgresql://user:pass@db-host:5432/optuna",
)
study.optimize(objective, n_trials=100)

הפעלה על ארבע מכונות עם 100 ניסויים לכל אחת תיתן 400 ניסויים סך הכל, מתואמים ובטוחים לתחרות (Optuna משתמשת ב־row-level locking). בגרסה 4 נוסף גם JournalStorage, אחסון מבוסס קבצי JSON שעובד גם ללא DB, מצוין לניסויים על HPC clusters עם NFS משותף.

שמירת מצב אוטומטית באמצעות SQLite מאפשרת גם רק להמשיך מריצה שנפלה. אם ה־kernel קרס אחרי 73 ניסויים, פתיחת אותו study תחזיר לכם את ההיסטוריה. אל תשכחו: load_if_exists=True בקריאה ל־create_study מונע שגיאה אם ה־study כבר קיים באחסון.

study = optuna.create_study(
    study_name="lgb-fraud",
    storage="sqlite:///optuna_studies.db",
    direction="maximize",
    load_if_exists=True,
)

שגיאות נפוצות ואיך להימנע מהן

מתוך עבודה על מאות ריצות אופטימיזציה, ריכזתי חמש טעויות שאני רואה חוזרות אצל צוותים מתחילים ואפילו מנוסים.

1. אימון על מערך המבחן. מפתה להעביר את מערך המבחן כ־validation set בתוך ה־objective, אבל זה זיהום מובהק. כל ריצת Optuna חייבת להשתמש רק במערך האימון, פנימית ל־CV. את מערך המבחן שמרו למדידה אחת בסוף. אני נתקלתי בבאג הזה בדיוק כשהעברתי מודל לייצור, ותקנתי אותו רק אחרי שהמדדים בפרודקשן היו נמוכים ב־7 נקודות אחוז.

2. מרחב חיפוש רחב מדי. אם אתם מגדירים learning_rate בין 1e-8 ל־10 בסקאלה לוגריתמית, TPE יבזבז 20 ניסויים במרחבים חסרי משמעות. הכלל שלי: אחרי 30 ניסויים ראשוניים, הפעילו plot_slice, ראו את הטווח האפקטיבי ורוצו שוב עם מרחב מצומצם.

3. התעלמות מ־random_state. אם המודל שלכם משתמש ברנדומיות (RandomForest, XGBoost), חוסר קיבוע seed הופך את ה־objective לרועש. Optuna תפרש רעש כאות ותנחית ניסויים במקומות שגויים. תמיד קבעו random_state=42 (או כל מספר קבוע) בתוך ה־objective.

4. שכחת n_jobs=-1. ברירת המחדל של Optuna היא ריצה סדרתית של ניסויים. אם ה־objective שלכם קצר יחסית, הפעילו study.optimize(objective, n_trials=100, n_jobs=4) להרצת ארבעה ניסויים במקביל בתהליך אחד. שימו לב: זה עובד רק אם ה־objective עצמו לא כבר משתמש בכל הליבות.

5. אי־שימוש ב־Pruner. ניסויים איטיים בלי pruner הם בזבוז זמן טהור. אפילו MedianPruner בסיסי חוסך 30%–50% מזמן הריצה בממוצע. הוסיפו אותו לכל ריצה גדולה מ־50 ניסויים.

שאלות נפוצות

מה זה Optuna בעצם?

Optuna היא ספריית קוד פתוח בפייתון לאופטימיזציית היפרפרמטרים בלמידת מכונה, שפותחה על ידי Preferred Networks. היא משתמשת באלגוריתמים של Bayesian Optimization (בעיקר TPE) כדי למצוא בצורה אדפטיבית את הצירוף הטוב ביותר של היפרפרמטרים, ומחליפה גישות מיושנות כמו GridSearchCV. הגרסה הנוכחית ביולי 2026 היא 4.0, עם תמיכה מלאה ב־Python 3.10 ומעלה.

מה ההבדל בין Optuna ל־GridSearchCV?

GridSearchCV סורק כל צירוף אפשרי במרחב מוגדר מראש, יעיל למרחבים קטנים אך אקספוננציאלי במרחבים גדולים. Optuna לומדת מהניסויים הקודמים ומעדיפה אזורים מבטיחים, לרוב מגיעה לתוצאה טובה יותר ב־30%–50% פחות ניסויים. בנוסף, Optuna תומכת ב־Pruning של ניסויים חלשים, במרחב חיפוש דינמי ובאופטימיזציה מרובת מטרות, יכולות שאין ב־GridSearchCV.

האם Optuna עובדת עם PyTorch ו־TensorFlow?

כן, Optuna תומכת בכל framework של למידה עמוקה כי פונקציית ה־objective היא קוד פייתון רגיל. חבילת optuna-integration מספקת callbacks מוכנים ל־PyTorch Lightning, Keras/TensorFlow, FastAI ו־HuggingFace Trainer שמאפשרים Pruning אוטומטי בכל epoch, ללא כתיבת קוד דיווח ידני.

כמה ניסויים כדאי להריץ?

ככלל אצבע, 50–100 ניסויים מספיקים למרחב חיפוש של 3–5 היפרפרמטרים. עבור 6–10 היפרפרמטרים אני ממליצה על 200–500 ניסויים. הדרך הטובה ביותר היא להריץ במרכיבים: ריצה של 30 ניסויים ואחריה בדיקה עם plot_optimization_history. אם העקומה עוד יורדת, המשיכו; אם היא שטוחה זמן ארוך, יש התכנסות.

האם Optuna חינמית לשימוש מסחרי?

כן. Optuna מופצת ברישיון MIT, שהוא רישיון מתירני שמתיר שימוש מסחרי, שינוי והפצה מחדש ללא תשלום. הפיתוח נתמך ומנוהל על ידי Preferred Networks עם קהילה פעילה של מאות תורמים ב־GitHub.

איך שומרים את התוצאות של אופטימיזציה ומחזירים אותן?

העבירו פרמטר storage="sqlite:///optuna.db" ל־create_study וכל ניסוי יישמר באופן קבוע. כדי לטעון study קיים: optuna.load_study(study_name="my_study", storage="sqlite:///optuna.db"). אחר כך תוכלו לגשת ל־study.trials_dataframe() לניתוח או לפתוח דשבורד עם optuna-dashboard sqlite:///optuna.db.