Optuna詳解: Pythonによるハイパーパラメータ自動最適化ライブラリ

Optunaが多くの開発者や研究者に支持される理由は、その豊富な機能にあります。

• 多様な探索アルゴリズム (Sampler):
  • ベイズ最適化に基づき、効率的な探索を行う「TPE (Tree-structured Parzen Estimator)」（デフォルト）
  • シンプルな「ランダムサンプリング (RandomSampler)」
  • 連続値空間で強力な進化戦略アルゴリズム「CMA-ES (Covariance Matrix Adaptation Evolution Strategy)」
  • 多目的最適化のための「NSGA-II」
  • 指定したパラメータ候補を試す「グリッドサーチ (GridSampler)」
  • など、様々なアルゴリズムをサポートしており、タスクに応じて選択できます。
• 効率的な枝刈り (Pruning):
  • 学習の初期段階で成果が見込めない試行（Trial）を自動的に打ち切る機能です。
  • 「MedianPruner」（デフォルト）、「SuccessiveHalvingPruner」、「HyperbandPruner」などのアルゴリズムが利用可能で、計算資源を無駄にせず、最適化プロセス全体を高速化します。
• 簡単なAPIとPythonicな設計:
  • 直感的でPythonらしい書き方ができるAPIを提供します。「Define-by-Run」により、Pythonの制御構文を使って柔軟に探索空間を定義できます。
• 強力な可視化機能 (Visualization):
  • 最適化の履歴、パラメータの重要度、パラメータ間の関係（等高線プロット、パラレルコーディネートプロット）、枝刈りの様子などを簡単に可視化できます。（`plotly`ライブラリが必要です）
  • これにより、最適化プロセスを深く理解し、さらなる改善につなげることが可能です。
• 容易な並列・分散最適化:
  • 複数のCPUコアや複数のマシンを使って、最適化プロセスを並列化・分散化することが容易です。データベース（SQLite, PostgreSQL, MySQLなど）やNFSを介して試行結果を共有することで、コードをほとんど変更することなくスケーリングできます。
• Webダッシュボード (Optuna Dashboard):
  • 最適化の進捗状況をリアルタイムで確認できるWebベースのダッシュボード機能があります。グラフや表で履歴やパラメータ重要度などをインタラクティブに確認できます。（`optuna-dashboard`パッケージが必要です）
  • VS CodeやJupyterLabの拡張機能としても提供されています。
• フレームワーク非依存:
  • Scikit-learn, PyTorch, TensorFlow, Keras, LightGBM, XGBoost, AllenNLP, FastAIなど、特定の機械学習フレームワークに縛られず、様々なライブラリと連携して使用できます。一部ライブラリには専用の連携モジュール（Integration）も提供されています。
• 活発な開発とコミュニティ:
  • オープンソースプロジェクトとして活発に開発が続けられており、新機能の追加や改善が頻繁に行われています。（2025年1月にはバージョン4.2.0がリリースされました）
  • GitHub上での議論や貢献も活発です。
  • OptunaHubという機能共有プラットフォームも登場し、ユーザーが実装したサンプラーなどを共有・利用できます。

Optunaはpipを使って簡単にインストールできます。

pip install optuna

可視化機能やダッシュボード、特定の連携機能を使用するには、追加のライブラリが必要です。例えば、可視化にPlotlyを、ダッシュボードを使用する場合は、以下のようにインストールします。

pip install plotly optuna-dashboard

特定の機械学習ライブラリとの連携モジュール（例: LightGBM連携）は、`optuna-integration`パッケージに含まれている場合があります。必要に応じてインストールしてください。

pip install optuna-integration

OptunaはPython 3.8以上をサポートしています。

Optunaを使ったハイパーパラメータ最適化は、基本的に以下の3つのステップで行います。

1. 目的関数 (Objective Function) の定義: 最適化したい評価指標（例: 精度、損失）を計算して返す関数を定義します。この関数内で、探索したいハイパーパラメータを `trial` オブジェクトを使って指定します。
2. Studyオブジェクトの作成: 最適化のセッション全体を管理する `Study` オブジェクトを作成します。ここで最適化の方向（最小化/最大化）や使用するSampler、Prunerを指定できます。
3. 最適化の実行: `study.optimize()` メソッドを呼び出し、定義した目的関数と試行回数（`n_trials`）を指定して最適化を実行します。

ステップ1: 目的関数 (Objective Function) の定義

目的関数は、`trial` オブジェクトを引数として受け取ります。`trial` オブジェクトの `suggest_` メソッドを使って、探索したいハイパーパラメータとその範囲や候補を指定します。関数は最終的に最適化（最小化または最大化）したい評価指標の値を返す必要があります。

import optuna
import math

# 目的関数の例: (x - 2)^2 + (y - 1)^2 を最小化する
def objective(trial):
    # 探索するハイパーパラメータを定義
    # 'x' という名前の浮動小数点数を -10 から 10 の範囲で提案
    x = trial.suggest_float('x', -10.0, 10.0)
    # 'y' という名前の整数を 0 から 5 の範囲で提案
    y = trial.suggest_int('y', 0, 5)
    # 'optimizer' という名前のカテゴリ変数を ['Adam', 'SGD'] から提案
    # optimizer_name = trial.suggest_categorical('optimizer', ['Adam', 'SGD'])

    # 評価指標 (最小化したい値) を計算
    score = (x - 2)**2 + (y - 1)**2

    # 評価指標を返す
    return score

# 他のsuggestメソッドの例
# def objective_other_suggests(trial):
#     # 対数スケールで探索 (1e-5 から 1e-1 の範囲)
#     learning_rate = trial.suggest_float('lr', 1e-5, 1e-1, log=True)
#     # 離散的な浮動小数点数の候補から選択
#     dropout_rate = trial.suggest_float('dropout', 0.1, 0.5, step=0.1)
#     # 整数の候補から選択
#     num_layers = trial.suggest_int('layers', 1, 5)
#     # カテゴリ変数の候補から選択
#     activation = trial.suggest_categorical('activation', ['ReLU', 'Tanh'])
#     # 処理...
#     return some_score

主な `suggest_` メソッドには以下のようなものがあります。

• `suggest_float()`: 浮動小数点数を指定された範囲で探索します (`log=True`で対数スケール、`step`で離散値も可能)。
• `suggest_int()`: 整数を指定された範囲で探索します (`step`で間隔指定、`log=True`で対数スケールも可能)。
• `suggest_categorical()`: リストで与えられたカテゴリ候補の中から選択します。

ステップ2: Studyオブジェクトの作成

`optuna.create_study()` でStudyオブジェクトを作成します。`direction` 引数で最適化の方向を指定します（`’minimize’` または `’maximize’`）。デフォルトは `’minimize’` です。SamplerやPrunerもここで指定できます。

# Studyオブジェクトを作成 (デフォルトは最小化)
study = optuna.create_study(direction='minimize')

# 例: 最大化を目指す場合
# study_maximize = optuna.create_study(direction='maximize')

# 例: Samplerを指定する場合 (後述)
# sampler = optuna.samplers.RandomSampler(seed=42)
# study_with_sampler = optuna.create_study(sampler=sampler)

ステップ3: 最適化の実行

`study.optimize()` メソッドに目的関数と試行回数 (`n_trials`) を渡して実行します。`timeout` で時間制限を設けることも可能です。

# 最適化を実行 (100回の試行)
# n_jobs=-1 とすると利用可能なCPUコア数で並列実行 (Joblibが必要)
study.optimize(objective, n_trials=100)

最適化が完了すると、`study` オブジェクトから最良の結果を取得できます。

# 最適化結果の表示
best_trial = study.best_trial
print(f"試行回数: {len(study.trials)}")
print(f"最適化後の最良値 (Best Value): {best_trial.value}")
print(f"最適化後の最良パラメータ (Best Params): {best_trial.params}")
# print(f"最良の試行 (Best Trial): {best_trial}") # 詳細情報

# すべての試行結果をデータフレームで取得することも可能 (pandasが必要)
# import pandas as pd
# df_trials = study.trials_dataframe()
# print(df_trials.head())

Samplerは、次の試行でどのハイパーパラメータの組み合わせを試すかを決定するアルゴリズムです。Optunaは複数のSamplerを提供しており、`create_study` 時に指定できます。

• TPESampler (Tree-structured Parzen Estimator): デフォルトのSamplerです。ベイズ最適化の一種で、過去の試行結果をもとに有望な領域を効率的に探索します。多くの場合、ランダムサーチよりも少ない試行回数で良い結果が得られます。
• RandomSampler: 指定された範囲からランダムにパラメータを選択します。シンプルですが、探索空間が広い場合や初期の探索に適しています。ベースラインとしても有用です。
• CmaEsSampler: 進化戦略アルゴリズムの一種であるCMA-ESに基づいています。特に連続値パラメータ空間の最適化に強力ですが、計算コストは高めです。
• GridSampler: 指定されたパラメータ候補のすべての組み合わせを試します（グリッドサーチ）。探索空間を `create_study` の `sampler` 引数に渡す必要があります。パラメータ空間が小さい場合に有効ですが、次元数が多くなると組み合わせ爆発を起こし非効率になります。
• NSGAIISampler: 多目的最適化（複数の目的関数を同時に最適化）のためのSamplerです。
• GPSampler (Gaussian Process Sampler): ガウス過程に基づくベイズ最適化Samplerです。バージョン4.2からは制約付き最適化にも対応しました。
• その他: 特定の用途向けのSamplerや、OptunaHubで共有されているカスタムSamplerなども利用可能です。

Samplerを指定する例:

import optuna

# TPE Samplerを使用 (デフォルトなので明示的な指定は不要な場合が多い)
# 乱数シードを設定して再現性を確保
sampler_tpe = optuna.samplers.TPESampler(seed=42)
study_tpe = optuna.create_study(sampler=sampler_tpe, direction='minimize')

# Random Samplerを使用
sampler_random = optuna.samplers.RandomSampler(seed=42)
study_random = optuna.create_study(sampler=sampler_random, direction='minimize')

# Grid Samplerを使用 (探索空間を指定する必要がある)
search_space_grid = {
    'x': [-5.0, 0.0, 5.0], # 試したいxの値
    'y': [0, 1, 2]      # 試したいyの値
}
sampler_grid = optuna.samplers.GridSampler(search_space_grid)
# Grid Samplerを使う場合、目的関数内のsuggestメソッドはGridSamplerが無視するため、
# どんな範囲を指定してもsearch_space_gridの値が使われます。
# ただし、suggestメソッド自体は呼び出す必要があります。
study_grid = optuna.create_study(sampler=sampler_grid, direction='minimize')

# Grid Samplerで最適化を実行 (組み合わせは 3 * 3 = 9 通り)
# study_grid.optimize(objective, n_trials=9) # n_trialsは組み合わせ数以上に設定しても意味がない
# print(f"Grid Search Best Params: {study_grid.best_params}")

Pruning（枝刈り）は、明らかに有望でない試行（Trial）を早期に打ち切ることで、最適化プロセス全体の計算コストを削減するテクニックです。特に、深層学習のように1回の試行に時間がかかる場合に有効です。

Pruningを利用するには、目的関数内で定期的に中間評価値を `trial.report(intermediate_value, step)` で報告し、`trial.should_prune()` で枝刈りすべきかどうかを判定する必要があります。`should_prune()` が `True` を返した場合、`optuna.TrialPruned` 例外を送出して試行を終了させます。

目的関数での中間値報告と枝刈り判定

import optuna
import time
# import sklearn.datasets
# import sklearn.linear_model
# import sklearn.model_selection

# 例: 機械学習モデルの学習途中で精度を報告し、枝刈りを判定する
# (実際にはPyTorchやTensorFlowのコールバックを使うことが多い)
def objective_with_pruning_example(trial):
    # 例としてロジスティック回帰のパラメータを探索
    solver = trial.suggest_categorical('solver', ['liblinear', 'saga'])
    C = trial.suggest_float('C', 1e-3, 1e3, log=True)

    # ダミーの学習プロセスをシミュレート
    n_epochs = 50
    for epoch in range(n_epochs):
        # ここでモデルの学習や計算を行う
        time.sleep(0.1) # 時間のかかる処理を模倣

        # 中間評価値を計算 (例: そのエポックでの検証精度)
        # ここではダミーの値を計算
        intermediate_accuracy = 1.0 - math.exp(-0.1 * epoch) * abs(math.log10(C)) / 3.0 + (0.1 if solver == 'liblinear' else 0.0)
        intermediate_accuracy = max(0.0, min(1.0, intermediate_accuracy)) # 0-1に収める

        # 中間評価値を報告 (stepはエポック数など)
        trial.report(intermediate_accuracy, step=epoch)

        # 枝刈りの判定
        if trial.should_prune():
            print(f"Trial {trial.number} pruned at step {epoch}.")
            # TrialPruned例外を送出して試行を打ち切る
            raise optuna.TrialPruned()

    # 全エポック完了後の最終評価値 (ここでは最後の中間値を使う)
    final_accuracy = intermediate_accuracy
    print(f"Trial {trial.number} finished with accuracy: {final_accuracy:.4f}")
    return final_accuracy # 目的は最大化とする

Prunerの種類

どのタイミングで、どのような基準で枝刈りを行うかは、Prunerによって決まります。`create_study` 時に `pruner` 引数で指定します。

• MedianPruner: デフォルトのPrunerです。同じステップ（例: エポック数）における過去の試行の中間評価値の中央値と比較し、それを下回る場合に枝刈りを行います。シンプルで多くの場合に有効です。
• SuccessiveHalvingPruner: 限られた計算リソース（例: エポック数）を段階的に有望な試行に割り当てるアルゴリズムです。各段階（Rung）でパフォーマンスの低い試行群を打ち切ります。
• HyperbandPruner: Successive Halvingを拡張し、異なるリソース量で複数のSuccessive Halvingを実行することで、より頑健な枝刈りを目指します。
• ThresholdPruner: 中間評価値が指定した閾値を上回る（または下回る）場合に枝刈りを行います。
• PercentilePruner: 中央値の代わりに、指定したパーセンタイルの値と比較します。

Prunerを指定する例:

# Median Prunerを使用 (デフォルトなので明示的な指定は不要な場合が多い)
pruner_median = optuna.pruners.MedianPruner(
    n_startup_trials=5, # 最初の5試行は枝刈りしない
    n_warmup_steps=10,  # 最初の10ステップは枝刈りしない
    interval_steps=1    # 1ステップごとに枝刈りを検討
)
study_median = optuna.create_study(pruner=pruner_median, direction='maximize') # 精度最大化

# Successive Halving Prunerを使用
pruner_sh = optuna.pruners.SuccessiveHalvingPruner(
    min_resource=1,        # 最小リソース (例: 1エポック)
    reduction_factor=4,    # 各段階で残す試行の割合 (1/4)
    min_early_stopping_rate=0 # 停止レート
)
study_sh = optuna.create_study(pruner=pruner_sh, direction='maximize')

# 最適化の実行 (枝刈り対応の目的関数を使用)
# print("--- Running study with Median Pruner ---")
# study_median.optimize(objective_with_pruning_example, n_trials=30)
# print(f"Best params (Median Pruner): {study_median.best_params}")

# print("\n--- Running study with Successive Halving Pruner ---")
# study_sh.optimize(objective_with_pruning_example, n_trials=30)
# print(f"Best params (Successive Halving Pruner): {study_sh.best_params}")

注意: Pruningは目的関数側での `report()` と `should_prune()` の実装が必須です。また、SamplerとPrunerの組み合わせによっては期待通りに動作しない場合もあるため、ドキュメントを確認することが推奨されます。

Optunaは、最適化の結果や過程を理解するのに役立つ豊富な可視化機能を提供します。これらの機能を利用するには、`plotly` ライブラリのインストールが必要です (`pip install plotly`)。

`optuna.visualization` モジュールに含まれる関数を使って、以下のようなプロットを作成できます。

• 最適化履歴 (Optimization History): `plot_optimization_history(study)` – 各試行の目的関数の値がどのように推移したか、およびその時点での最良値がどのように更新されていったかを示します。最適化が収束しているかを確認できます。
• パラメータ重要度 (Parameter Importances): `plot_param_importances(study)` – どのハイパーパラメータが目的関数の値に最も影響を与えたかを評価します。fANOVAやMean Decrease Impurityなどの手法に基づいて計算されます。（`scikit-learn` が必要になる場合があります）どのパラメータに注力してチューニングすべきかの判断材料になります。
• 等高線プロット (Contour Plot): `plot_contour(study, params=[‘param1’, ‘param2’])` – 指定した2つのハイパーパラメータと目的関数の値の関係を等高線で示します。パラメータ間の相互作用や最適な領域を視覚的に理解するのに役立ちます。（パラメータが2つ以上必要です）
• スライスマップ (Slice Plot): `plot_slice(study)` – 各ハイパーパラメータについて、その値と目的関数の値の関係を個別にプロットします。個々のパラメータの影響を把握するのに適しています。
• パラレルコーディネートプロット (Parallel Coordinate Plot): `plot_parallel_coordinate(study)` – 複数のハイパーパラメータと目的関数の関係を、平行な軸を使って同時に表示します。高次元のパラメータ空間における試行の分布や、良い結果（低い/高い目的関数値）につながるパラメータの組み合わせの傾向を把握できます。
• 中間値プロット (Intermediate Values Plot): `plot_intermediate_values(study)` – 枝刈り機能を使っている場合に、各試行の中間評価値の推移をプロットします。枝刈りが効果的に機能しているか、どの試行が早期に打ち切られたかを確認できます。
• ランクプロット (Rank Plot): `plot_rank(study)` – Optuna v3.2で追加された機能。パラメータを軸とし、各試行を目的関数のランク（順位）で色付けしてプロットします。高次元空間でのパラメータと性能の関係性を把握するのに役立ちます。
• EDFプロット (Empirical Distribution Function Plot): `plot_edf(study)` – 目的関数の値の経験累積分布関数（EDF）を表示します。複数のStudyの結果を比較するのに便利です。
• タイムラインプロット (Timeline Plot): `plot_timeline(study)` – 各試行がいつ開始し、どれくらいの時間かかったかをタイムラインで表示します。並列実行時の状況などを把握するのに役立ちます。

プロットの例:

import optuna
import plotly # 事前に pip install plotly が必要

# 簡単な最適化を実行 (studyオブジェクトが既にあるとする)
# study = optuna.create_study(direction='minimize')
# study.optimize(objective, n_trials=50) # objective は事前に定義されているとする

# 最適化履歴のプロット
if len(study.trials) > 0:
    try:
        fig_history = optuna.visualization.plot_optimization_history(study)
        fig_history.show() # Jupyter Notebookなどでは自動表示されることも
    except Exception as e:
        print(f"最適化履歴プロット中にエラー: {e}")

# パラメータ重要度のプロット
# 注意: 試行回数が少ない場合や、パラメータが1つしかない場合などはエラーになることがある
if len(study.trials) > 1 and len(study.best_params) > 0 :
    try:
        # 目的関数が複数の値(multi-objective)を返す場合は target_name や target を指定する必要がある
        fig_importance = optuna.visualization.plot_param_importances(study)
        fig_importance.show()
    except Exception as e:
        # 例外が発生しやすいのでハンドリング
        print(f"パラメータ重要度のプロット中にエラー: {e}")
        print("試行回数が十分でないか、パラメータ空間に問題がある可能性があります。")

# 等高線プロット (パラメータが2つ以上の場合)
if len(study.best_params) >= 2:
    try:
        # プロットするパラメータを適切に選択 (例: 最初の2つ)
        params_to_plot = list(study.best_params.keys())[:2]
        fig_contour = optuna.visualization.plot_contour(study, params=params_to_plot)
        fig_contour.show()
    except Exception as e:
        print(f"等高線プロット中にエラー: {e}")
else:
    print("等高線プロットには少なくとも2つのパラメータが必要です。")

# パラレルコーディネートプロット
if len(study.trials) > 0 and len(study.best_params) > 0:
    try:
        fig_parallel = optuna.visualization.plot_parallel_coordinate(study)
        fig_parallel.show()
    except Exception as e:
        print(f"パラレルコーディネートプロット中にエラー: {e}")

# スライスマップ
if len(study.trials) > 0 and len(study.best_params) > 0:
    try:
        fig_slice = optuna.visualization.plot_slice(study)
        fig_slice.show()
    except Exception as e:
        print(f"スライスマップ中にエラー: {e}")

これらの可視化関数が返すのは Plotly の Figure オブジェクトや Matplotlib の Axes オブジェクトなので、さらにカスタマイズすることも可能です。

Optuna Dashboardは、実行中の最適化プロセスや過去の結果をリアルタイムで監視・分析するためのWebインターフェースです。`optuna-dashboard` パッケージをインストール (`pip install optuna-dashboard`) して利用します。

ダッシュボードを利用するには、最適化の試行履歴を永続的なストレージ（データベース）に保存する必要があります。最も簡単な方法はSQLiteを使用することですが、PostgreSQLやMySQLなどのRDBも利用できます。

SQLiteをストレージとしてStudyを作成する例:

import optuna

# SQLiteデータベースファイルを指定してStudyを作成
# study_name: 複数のStudyを管理する場合に識別子となる
# storage: データベース接続文字列 (SQLiteの場合は 'sqlite:///ファイル名.db')
# load_if_exists=True: 同じ名前とストレージのStudyが存在すれば、それをロードして再開する
storage_url = "sqlite:///optuna_dashboard_study.db"
study_for_dashboard = optuna.create_study(study_name="my_ml_optimization_v1",
                                          storage=storage_url,
                                          load_if_exists=True,
                                          direction="maximize") # 例: 精度最大化

# ここで study_for_dashboard.optimize(objective, ...) を実行する
# (実行はバックグラウンドや別のプロセスで行っても良い)
# 例:
# def some_objective(trial):
#   acc = trial.suggest_float("acc", 0.5, 0.99)
#   time.sleep(1)
#   return acc
# study_for_dashboard.optimize(some_objective, n_trials=50)

Studyをデータベースに保存したら、ターミナル（コマンドプロンプト）から以下のコマンドを実行してダッシュボードを起動します。

optuna-dashboard sqlite:///optuna_dashboard_study.db

上記のコマンドを実行すると、デフォルトでは `http://localhost:8080/` でダッシュボードにアクセスできるようになります。

Optunaダッシュボードでは、以下のような情報をインタラクティブに確認できます。

• Studyの一覧と各Studyの詳細情報
• 試行（Trial）の一覧、パラメータ、目的値、状態（実行中、完了、枝刈り済みなど）
• 最適化履歴、パラメータ重要度、等高線プロット、パラレルコーディネートなどの可視化グラフ
• 試行のフィルタリングやソート
• Studyの作成や削除（一部機能）

ダッシュボードは、最適化が長時間にわたる場合や、分散環境で複数のワーカーが同時に最適化を実行している状況を監視するのに特に役立ちます。

VS CodeやJupyter Labの拡張機能としても提供されており、エディタ内で直接ダッシュボードを起動することも可能です。また、ブラウザだけで動作する実験的なバージョンも存在し、SQLiteファイルをドラッグ＆ドロップするだけで利用できます。

Optunaは、複数のプロセスやマシン（ノード）を使って最適化を並列実行する「分散最適化」を容易に実現できます。これにより、特に試行回数を多く必要とする場合や、1回の試行に時間がかかる場合に、最適化にかかる時間を大幅に短縮できます。

分散最適化の基本的な仕組みは、共有ストレージ（通常はRDB）を介して、複数のワーカー（最適化を実行するプロセス/マシン）が同じStudyの情報を共有し、協調して最適化を進めるというものです。

セットアップの概要:

1. 共有ストレージの準備: 全てのワーカーからアクセス可能なデータベース（PostgreSQL, MySQL推奨。小規模ならSQLiteも可だが性能問題の可能性あり）を用意します。あるいは、NFSなどの共有ファイルシステム上にSQLiteファイルを置く方法もありますが、DBの方が推奨されます。
2. Studyの作成（初回のみ）: 共有ストレージを指定して `optuna.create_study()` を実行します。`study_name` を設定し、`load_if_exists=True` を指定することが重要です。
3. 各ワーカーでの最適化実行: 各ワーカーで、同じ `study_name` と `storage` を指定して `optuna.create_study()` を呼び出し（`load_if_exists=True` により既存のStudyがロードされます）、`study.optimize()` を実行します。

例（概念）:

まず、データベースサーバー（例: PostgreSQL）をセットアップし、アクセス可能な状態にしておきます。

次に、各ワーカーで実行するPythonスクリプト (`worker.py`) を用意します。

# worker.py
import optuna
import time
import os

# 環境変数などからDB接続情報を取得するのが一般的
db_url = os.environ.get("OPTUNA_DB_URL", "postgresql://user:password@db_host:5432/optuna_study_db")
study_name = "distributed_optimization_example"

def objective_for_distributed(trial):
    x = trial.suggest_float("x", -5, 5)
    y = trial.suggest_int("y", 0, 10)
    # 時間のかかる処理をシミュレート
    time.sleep(2)
    score = (x ** 2) + (y - 5) ** 2
    return score

if __name__ == "__main__":
    # 同じStudy名とStorageを指定
    study = optuna.create_study(
        study_name=study_name,
        storage=db_url,
        load_if_exists=True,
        direction="minimize"
    )

    # このワーカーが担当する試行回数を実行
    # 実際には全体の試行回数を管理する仕組みが必要になることが多い
    # n_jobs > 1 でノード内並列も組み合わせられる
    study.optimize(objective_for_distributed, n_trials=20)

    # リーダーワーカーなど、どこか一箇所で結果を集計・表示
    # if is_leader_worker: # リーダーかどうかを判定するロジックが必要
    #    print(f"Best trial after optimization: {study.best_trial}")

この `worker.py` を、複数のマシンやプロセスで同時に実行します。各ワーカーはデータベースに接続し、他のワーカーが完了した試行の結果を考慮しながら、次に試すべきパラメータの提案を受け取り、目的関数を実行して結果をデータベースに書き込みます。

大規模な分散最適化（数百ワーカーなど）を行う場合、データベースへのアクセスがボトルネックになることがあります。Optuna v4.2では、このようなケースに対応するため、gRPCを用いたストレージプロキシ機能が導入され、RDBへの負荷を軽減できるようになりました。

また、JoblibのSparkバックエンドやDaskを利用して分散実行を管理するアプローチや、`optuna-distributed` のような拡張ライブラリも存在します。

Optunaは特定の機械学習フレームワークに依存しないため、様々なライブラリと組み合わせて利用できます。`optuna.integration` モジュール（または別パッケージ `optuna-integration`）には、いくつかの主要ライブラリとの連携を容易にするための機能が含まれています。

• Scikit-learn:
  • 手動で目的関数内にモデル学習と評価を記述する方法が基本です。クロスバリデーションのスコアなどを目的値として返します。
  • `OptunaSearchCV` という `GridSearchCV` や `RandomizedSearchCV` に似たインターフェースを提供するクラスもありますが、柔軟性の点では手動実装が推奨されることもあります。
• PyTorch / TensorFlow / Keras:
  • 学習ループ内でOptunaの目的関数を定義し、学習率、バッチサイズ、オプティマイザの種類、ネットワーク構造（層の数、ユニット数）などを `trial.suggest_` で決定します。
  • 学習の各エポックやステップで検証ロスなどを `trial.report()` で報告し、`trial.should_prune()` で枝刈りを実装することが一般的です。各フレームワークが提供するコールバック機能と連携させるためのクラス（例: `PyTorchLightningPruningCallback`, `TensorFlowPruningHook`, `KerasPruningCallback`）が `integration` モジュールに用意されています。
• LightGBM / XGBoost:
  • これらの勾配ブースティングライブラリには、学習途中の評価値を取得し、枝刈りを行うためのコールバックAPIが用意されています。Optunaはこれを利用した連携クラス（例: `LightGBMPruningCallback`, `XGBoostPruningCallback`）を提供しており、効率的な枝刈りが可能です。
  • `LightGBMTunerCV` のように、クロスバリデーションとハイパーパラメータ最適化をまとめて行う便利なクラスも提供されています。
• その他:
  • AllenNLP, FastAI, MXNet, CatBoost, Chainer など、多くのライブラリとの連携実績や専用モジュールが存在します。
  • MLflowとの連携もサポートされており (`MLflowCallback`)、Optunaの試行結果をMLflowで追跡・管理することが可能です。Databricks環境などでの利用例があります。

Scikit-learnとの連携例（手動実装）:

import optuna
from sklearn.model_selection import cross_val_score
from sklearn.svm import SVC
from sklearn.datasets import load_iris
import numpy as np

# Scikit-learnを用いた目的関数の例 (アヤメ分類データでSVCのパラメータ最適化)
def objective_sklearn(trial):
    # データセットのロード
    X, y = load_iris(return_X_y=True)

    # 探索するハイパーパラメータを定義
    # カーネルの種類
    kernel = trial.suggest_categorical('kernel', ['linear', 'rbf', 'poly'])
    # 正則化パラメータ C (対数スケールで探索)
    svc_c = trial.suggest_float('C', 1e-2, 1e2, log=True)

    # カーネルに応じて追加のパラメータを探索 (Define-by-Run)
    if kernel == 'rbf':
        svc_gamma = trial.suggest_float('gamma', 1e-3, 1e1, log=True)
    elif kernel == 'poly':
        svc_gamma = trial.suggest_float('gamma', 1e-3, 1e1, log=True) # polyもgammaを持つ
        svc_degree = trial.suggest_int('degree', 2, 5)
    else: # linear の場合
        # gammaやdegreeは不要
        svc_gamma = 'auto' # または適切なデフォルト値
        svc_degree = 3     # または適切なデフォルト値

    # モデルの定義
    # polyの場合のみdegreeを指定
    if kernel == 'poly':
         clf = SVC(kernel=kernel, C=svc_c, gamma=svc_gamma, degree=svc_degree, random_state=42)
    else:
         clf = SVC(kernel=kernel, C=svc_c, gamma=svc_gamma, random_state=42)


    # クロスバリデーションで評価 (精度を最大化)
    # 例外処理を追加するとより頑健になる
    try:
        accuracy = cross_val_score(clf, X, y, n_jobs=1, cv=5).mean() # n_jobs=-1はネストした並列化になる可能性があるので注意
    except Exception as e:
        print(f"エラー発生: {e}, パラメータ: {trial.params}")
        accuracy = -np.inf # エラー時は非常に低い値を返す (最大化の場合)

    return accuracy

# 最適化の実行
# study_sklearn = optuna.create_study(direction='maximize')
# study_sklearn.optimize(objective_sklearn, n_trials=100, n_jobs=1) # n_jobs > 1 で試行を並列化

# print(f"Best accuracy: {study_sklearn.best_value:.4f}")
# print(f"Best params: {study_sklearn.best_params}")

`optuna-integration` パッケージは、Optuna本体とは別に開発・リリースが進められています。最新の情報や対応ライブラリについては、公式ドキュメントやリポジトリを確認してください。

Optunaには、基本的なハイパーパラメータ最適化以外にも、より高度な機能や使い方が用意されています。

• 多目的最適化 (Multi-objective Optimization):
  • 複数の目的関数（例: モデルの精度と推論速度の両方）を同時に最適化したい場合があります。`optuna.create_study(directions=[‘maximize’, ‘minimize’])` のように `directions` リストで各目的の最適化方向を指定します。
  • 結果は単一の最良値ではなく、「パレート最適解」の集合として得られます (`study.best_trials`)。`NSGAIISampler` などがこの目的でよく使われます。
  • 可視化関数 `plot_pareto_front` でパレートフロントをプロットできます。
• 制約条件付き最適化 (Constrained Optimization):
  • 特定のハイパーパラメータの組み合わせに制約（例: メモリ使用量が上限を超えない、パラメータAの値はパラメータBより小さいなど）を設けたい場合があります。
  • Optuna v3.0以降、TPE Samplerが制約条件を扱えるようになりました。目的関数が目的値と制約違反のリスト（またはタプル）を返すように実装します。
  • バージョン4.2ではGPSamplerも不等式制約を扱えるようになりました。
• バッチ最適化 (Batch Optimization):
  • `study.optimize` は通常、1つずつ試行を実行しますが、複数の試行をまとめて（バッチで）実行・評価したい場合に利用できる機能もあります（`ask()` と `tell()` メソッドを使った低レベルAPI）。
• ユーザー定義属性 (User Attributes):
  • 各試行に、目的値やパラメータ以外の任意の情報（例: 学習にかかった時間、モデルのファイルパス、特定の評価メトリクスなど）を `trial.set_user_attr(key, value)` で付与できます。後で分析などに活用できます。
• コールバック (Callbacks):
  • `study.optimize()` の `callbacks` 引数に関数を渡すことで、各試行が完了するたびに特定の処理（ログ記録、途中結果の保存、早期停止条件のチェックなど）を実行させることができます。
  • `MLflowCallback` など、連携機能もコールバックとして実装されています。
• サンプラー・プルーナーのカスタマイズ:
  • 既存のSamplerやPrunerを継承したり、完全に独自のアルゴリズムを実装したりすることも可能です。