粒子群最適化（PSO）を実装してみよう！わかりやすく解説

【スマホからでも実行可能】粒子群最適化（PSO）のアルゴリズムをPythonで実装し、その仕組みを初心者にもわかりやすく解説します。最適化問題や機械学習に興味がある方におすすめです。パラメータ設定のコツや応用例も紹介し、実践的な理解を深めます。

Tags:#アルゴリズム実践

はじめに

粒子群最適化（PSO: Particle Swarm Optimization）は、たくさんの「粒子」たちが協力し合って、一番良い答えを見つけ出すアルゴリズムです。なんだか難しそうに聞こえるかもしれませんが、実は自然界の鳥の群れや魚の群れがエサを探す行動をヒントにしています。

この「実践編」では、PSOがどのようにして最適な答えを見つけ出すのか、その具体的なステップをPythonというプログラミング言語を使って一緒に見ていきます。「入門編」や「活用例編」をまだご覧になっていない方でも理解できるように、基本的な考え方から丁寧に解説しますのでご安心ください。

この記事を読み終える頃には、PSOの動きを具体的にイメージできるようになり、ご自身で簡単なPSOプログラムを動かせるようになることを目指します。複雑な数式は使わず、言葉と図、そして実際のコードで、PSOの世界を探検しましょう。

記事の最後に、環境構築なしでスマホからでも即実行可能なGoogle Colabノートブックをご用意しています。 ぜひ、実際にコードを動かしながら学んでみてください。

粒子群最適化（PSO）とは？（実践編のおさらい）

PSOでは、問題を解決するための「答えの候補」を「粒子」と呼びます。そして、たくさんの粒子たちが、まるで群れのように集まって、一番良い答えがありそうな場所（最適解）を探し回ります。

それぞれの粒子は、以下の2つの情報を頼りに、次にどこへ動くかを決めます。

自分が見つけた一番良い場所（個人的ベスト）: 各粒子は、これまでに自分が探検した中で最も良かった場所を覚えています。
群れ全体で見つけた一番良い場所（全体ベスト）: 群れ全体の粒子が発見した中で、最も良かった場所の情報も共有されます。

粒子たちは、この「個人的な経験」と「集団の知恵」をうまく組み合わせながら、より良い場所を目指して移動を繰り返します。最初はバラバラに散らばっていた粒子たちも、だんだんと有望なエリアに集まっていき、最終的に最適解（あるいはそれに非常に近い解）にたどり着く、という仕組みです。

この動きをもう少し具体的に見ていきましょう。

慣性: 粒子は、今まさに飛んでいる方向に、ある程度そのまま飛び続けようとします。急には方向を変えられない、というイメージです。
個人的ベストへの引力: 粒子は、自分が過去に見つけた一番良かった場所（個人的ベスト）へ引き寄せられます。「あっちの方向が良かったはずだ」という記憶に導かれるわけです。
全体ベストへの引力: 同時に、群れ全体で見つかった一番良い場所（全体ベスト）にも引き寄せられます。「みんながあそこが良いと言っているから、行ってみよう」という情報共有の効果です。

これらの要素が、粒子の次の動き（速度と位置）を決定します。この単純なルールに従って粒子たちが動き回ることで、複雑な問題の最適解を効率的に探索できるのがPSOの面白いところです。

PSOをPythonで実装してみよう

それでは、実際にPSOをPythonでプログラミングしてみましょう。ここでは、ある関数の最小値を見つける、という簡単な例題を通して、PSOの動きを体験します。

準備するもの

PythonでPSOを実装するために、特別なライブラリは必須ではありませんが、数値計算を効率的に行うためにNumPyというライブラリを使用します。また、結果をグラフで表示するためにMatplotlibというライブラリも使うと便利です。

これらのライブラリがもしお手元の環境になければ、インストールが必要です。Google Colabを使用する場合は、これらの基本的なライブラリはあらかじめ利用可能な状態になっていることが多いです。

import numpy as np
import matplotlib.pyplot as plt

評価関数（目的関数）の定義

まず、私たちが最小値を探したい関数を定義します。これを「評価関数」や「目的関数」と呼びます。今回は、例としてシンプルな2次元の関数（Sphere関数）を使ってみましょう。この関数は x^2 + y^2 という形で、原点 (0, 0) で最小値 0 を取ります。

# 評価関数（Sphere関数）
def sphere_function(position):
    return np.sum(position**2)

この関数は、粒子の「位置（position）」を入力として受け取り、その位置での「評価値」を返します。PSOの目的は、この評価値が最も小さくなる位置を見つけることです。

PSOのメインロジックの実装

次に、PSOのアルゴリズム本体を実装します。少し長くなりますが、各ステップをコメントで説明しますので、じっくりと読んでみてください。

def pso_optimizer(objective_function, bounds, num_particles, max_iterations, w, c1, c2):
    """
    粒子群最適化（PSO）を実行する関数

    引数:
    objective_function -- 評価関数（最小化したい関数）
    bounds -- 各次元の探索範囲 [(最小値1, 最大値1), (最小値2, 最大値2), ...]
    num_particles -- 粒子の数
    max_iterations -- 最大繰り返し数
    w -- 慣性重み
    c1 -- 個人的ベストへの加速係数
    c2 -- 全体ベストへの加速係数

    戻り値:
    gbest_position -- 見つかった最適解の位置
    gbest_value -- 見つかった最適解の評価値
    history -- 各イテレーションでの全体ベスト評価値の履歴
    """

    num_dimensions = len(bounds)  # 問題の次元数

    # 1. 粒子の初期化
    # 各粒子の位置を探索範囲内でランダムに設定
    particles_position = np.random.rand(num_particles, num_dimensions)
    for i in range(num_dimensions):
        particles_position[:, i] = particles_position[:, i] * (bounds[i][1] - bounds[i][0]) + bounds[i][0]

    # 各粒子の速度をランダムに初期化（通常は0に近い値や、探索範囲の数%程度）
    particles_velocity = np.random.rand(num_particles, num_dimensions) * 0.1

    # 各粒子の個人的ベスト（pbest）の位置と評価値を初期化
    pbest_position = np.copy(particles_position)
    pbest_value = np.array([objective_function(p) for p in pbest_position])

    # 全体ベスト（gbest）の位置と評価値を初期化
    # 最初の全体ベストは、個人的ベストの中で最も良いもの
    gbest_index = np.argmin(pbest_value)
    gbest_position = np.copy(pbest_position[gbest_index])
    gbest_value = pbest_value[gbest_index]

    # 評価値の履歴を保存するリスト
    history = [gbest_value]

    # 2. メインループ (繰り返し計算)
    for iteration in range(max_iterations):
        for i in range(num_particles):
            # 2-1. 各粒子の速度を更新
            r1 = np.random.rand(num_dimensions)  # 0から1までの一様な乱数（個人的ベスト用）
            r2 = np.random.rand(num_dimensions)  # 0から1までの一様な乱数（全体ベスト用）

            # 速度更新式
            # v_new = w * v_current + c1 * r1 * (pbest - x_current) + c2 * r2 * (gbest - x_current)
            particles_velocity[i] = (w * particles_velocity[i] +
                                     c1 * r1 * (pbest_position[i] - particles_position[i]) +
                                     c2 * r2 * (gbest_position - particles_position[i]))

            # 2-2. 各粒子の位置を更新
            # x_new = x_current + v_new
            particles_position[i] = particles_position[i] + particles_velocity[i]

            # 2-3. 探索範囲の制約を適用 (もし粒子が範囲外に出たら、範囲内に戻す)
            for dim in range(num_dimensions):
                if particles_position[i, dim] < bounds[dim][0]:
                    particles_position[i, dim] = bounds[dim][0]
                    particles_velocity[i, dim] *= -0.5 # 壁で跳ね返るイメージ（速度を反転・減衰）
                elif particles_position[i, dim] > bounds[dim][1]:
                    particles_position[i, dim] = bounds[dim][1]
                    particles_velocity[i, dim] *= -0.5 # 壁で跳ね返るイメージ

            # 2-4. 新しい位置での評価値を計算
            current_value = objective_function(particles_position[i])

            # 2-5. 個人的ベスト（pbest）を更新
            if current_value < pbest_value[i]:
                pbest_value[i] = current_value
                pbest_position[i] = np.copy(particles_position[i])

                # 2-6. 全体ベスト（gbest）を更新 (個人的ベストが更新された場合、それが全体ベストよりも良いかチェック)
                if current_value < gbest_value:
                    gbest_value = current_value
                    gbest_position = np.copy(particles_position[i])

        history.append(gbest_value) # 各イテレーションの最良評価値を記録
        if iteration % 10 == 0: # 10イテレーションごとに進捗を表示
            print(f"イテレーション {iteration+1}/{max_iterations}, ベスト評価値: {gbest_value:.6f}")

    return gbest_position, gbest_value, history

このコードがPSOの心臓部です。まず、指定された数の粒子を、探索範囲内にランダムに配置し、初期速度も与えます。そして、各粒子について「個人的ベスト（pbest）」を記録し、群れ全体で最も良い「全体ベスト（gbest）」も記録します。

メインループでは、各粒子が自分の速度と位置を更新します。速度の更新には、

現在の速度（慣性）
自分の個人的ベストに向かう力
群れの全体ベストに向かう力の3つの要素が影響します。w、c1、c2 というパラメータが、これらの影響の大きさを調整します。 r1 と r2 は乱数で、これによって粒子たちの動きに多様性が生まれ、局所的な最適解に陥りにくくする効果があります。

位置を更新したら、新しい位置が探索範囲を超えていないかチェックし、もし超えていたら範囲内に戻します（ここでは壁で跳ね返るような処理を入れていますが、他にも様々な方法があります）。そして、新しい位置で評価関数を計算し、もしそれが今までの個人的ベストよりも良ければ更新します。さらに、もしそれが今までの全体ベストよりも良ければ、全体ベストも更新します。

この一連の処理を、指定された最大繰り返し回数（max_iterations）だけ繰り返します。

パラメータ設定

PSOをうまく機能させるためには、いくつかのパラメータを適切に設定する必要があります。

# パラメータ設定
bounds = [(-10, 10), (-10, 10)]  # 探索範囲 (x軸は-10から10, y軸も-10から10)
num_particles = 30              # 粒子の数
max_iterations = 100            # 最大繰り返し数

# PSOの挙動を左右する重要なパラメータ
w = 0.5    # 慣性重み (通常0.4 ~ 0.9程度)
c1 = 1.5   # 個人的ベストへの加速係数 (通常1.0 ~ 2.0程度)
c2 = 1.5   # 全体ベストへの加速係数 (通常1.0 ~ 2.0程度)

bounds: 粒子の探索範囲です。問題に応じて適切な範囲を設定します。
num_particles: 粒子の数です。多すぎると計算時間がかかり、少なすぎると良い解を見逃す可能性があります。通常20〜50程度が使われます。
max_iterations: PSOを何回繰り返すかの上限です。
w（慣性重み）: 粒子が現在の進行方向をどれだけ維持するかを決めます。大きいと広範囲を探索しやすく、小さいと局所的な探索が強まります。
c1（認知係数／個人的加速係数）: 粒子が自身の過去の最良解（pbest）にどれだけ引かれるかを決めます。
c2（社会係数／全体的加速係数）: 粒子が群れ全体の最良解（gbest）にどれだけ引かれるかを決めます。

これらのパラメータは問題の性質や他のパラメータとの兼ね合いで最適な値が変わるため、いくつか試してみて調整することが一般的です。

実行と結果の確認

それでは、設定したパラメータでPSOを実行し、結果を見てみましょう。

# PSOの実行
best_position, best_value, history = pso_optimizer(sphere_function, bounds, num_particles, max_iterations, w, c1, c2)

print("\n--- 結果 ---")
print(f"最適解の位置: {best_position}")
print(f"最適解の評価値: {best_value}")

# 結果のプロット (評価値の収束グラフ)
plt.figure(figsize=(10, 6))
plt.plot(history)
plt.title("PSO Convergence (Sphere Function)")
plt.xlabel("Iteration")
plt.ylabel("Best Value Found")
plt.grid(True)
plt.show()

実行すると、各イテレーション（繰り返し）ごとの最良評価値が出力され、最後に最適と判断された位置とその評価値が表示されます。また、Matplotlibを使って、イテレーションが進むにつれて最良評価値がどのように変化（収束）していくかをグラフで表示します。Sphere関数の場合、評価値が0に近づいていく様子が確認できるはずです。

コード全体の提示

ここまでのPythonコードをまとめると以下のようになります。

import numpy as np
import matplotlib.pyplot as plt

# 1. 評価関数（目的関数）の定義
def sphere_function(position):
    """Sphere関数: sum(x_i^2)"""
    return np.sum(position**2)

# 2. PSOのメインロジック
def pso_optimizer(objective_function, bounds, num_particles, max_iterations, w, c1, c2):
    num_dimensions = len(bounds)

    # 粒子の初期化
    particles_position = np.random.rand(num_particles, num_dimensions)
    for i in range(num_dimensions):
        particles_position[:, i] = particles_position[:, i] * (bounds[i][1] - bounds[i][0]) + bounds[i][0]

    particles_velocity = np.random.rand(num_particles, num_dimensions) * 0.1 # 初期速度を小さめに

    pbest_position = np.copy(particles_position)
    pbest_value = np.array([objective_function(p) for p in pbest_position])

    gbest_index = np.argmin(pbest_value)
    gbest_position = np.copy(pbest_position[gbest_index])
    gbest_value = pbest_value[gbest_index]

    history = [gbest_value]

    # メインループ
    for iteration in range(max_iterations):
        for i in range(num_particles):
            # 速度更新
            r1 = np.random.rand(num_dimensions)
            r2 = np.random.rand(num_dimensions)
            particles_velocity[i] = (w * particles_velocity[i] +
                                     c1 * r1 * (pbest_position[i] - particles_position[i]) +
                                     c2 * r2 * (gbest_position - particles_position[i]))

            # 位置更新
            particles_position[i] = particles_position[i] + particles_velocity[i]

            # 探索範囲の制約
            for dim in range(num_dimensions):
                if particles_position[i, dim] < bounds[dim][0]:
                    particles_position[i, dim] = bounds[dim][0]
                    particles_velocity[i, dim] *= -0.5 # 速度を反転・減衰
                elif particles_position[i, dim] > bounds[dim][1]:
                    particles_position[i, dim] = bounds[dim][1]
                    particles_velocity[i, dim] *= -0.5 # 速度を反転・減衰

            # 評価
            current_value = objective_function(particles_position[i])

            # pbest更新
            if current_value < pbest_value[i]:
                pbest_value[i] = current_value
                pbest_position[i] = np.copy(particles_position[i])

                # gbest更新
                if current_value < gbest_value:
                    gbest_value = current_value
                    gbest_position = np.copy(particles_position[i])

        history.append(gbest_value)
        if (iteration + 1) % 10 == 0:
            print(f"イテレーション {iteration+1}/{max_iterations}, ベスト評価値: {gbest_value:.6f}")

    return gbest_position, gbest_value, history

if __name__ == '__main__':
    # 3. パラメータ設定
    bounds = [(-10, 10), (-10, 10)]  # 2次元問題、各次元の探索範囲は -10 から 10
    num_particles = 30
    max_iterations = 100
    w = 0.5   # 慣性重み
    c1 = 1.5  # 個人的ベストへの加速係数
    c2 = 1.5  # 全体ベストへの加速係数

    # 4. PSOの実行と結果の確認
    print("PSOを開始します...")
    best_position, best_value, history = pso_optimizer(
        sphere_function,
        bounds,
        num_particles,
        max_iterations,
        w, c1, c2
    )

    print("\n--- 結果 ---")
    print(f"見つかった最適解の位置: {best_position}")
    print(f"見つかった最適解の評価値: {best_value}")

    # 5. 結果のプロット
    plt.figure(figsize=(10, 6))
    plt.plot(history)
    plt.title("PSO Convergence Plot (Sphere Function)")
    plt.xlabel("Iteration")
    plt.ylabel("Best Value (gbest)")
    plt.grid(True)
    plt.show()

    # より複雑な関数（例：Rastrigin関数）で試す場合は、以下のように定義して差し替える
    # def rastrigin_function(position):
    #     A = 10
    #     n = len(position)
    #     return A * n + np.sum(position**2 - A * np.cos(2 * np.pi * position))
    #
    # bounds_rastrigin = [(-5.12, 5.12), (-5.12, 5.12)] # Rastrigin関数の一般的な探索範囲
    # print("\nRastrigin関数でPSOを開始します...")
    # best_position_r, best_value_r, history_r = pso_optimizer(
    #     rastrigin_function,
    #     bounds_rastrigin,
    #     num_particles,
    #     max_iterations * 2, # 複雑な関数なのでイテレーションを増やす
    #     w, c1, c2
    # )
    # print("\n--- Rastrigin関数の結果 ---")
    # print(f"見つかった最適解の位置: {best_position_r}")
    # print(f"見つかった最適解の評価値: {best_value_r}")
    # plt.figure(figsize=(10,6))
    # plt.plot(history_r)
    # plt.title("PSO Convergence Plot (Rastrigin Function)")
    # plt.xlabel("Iteration")
    # plt.ylabel("Best Value (gbest)")
    # plt.grid(True)
    # plt.show()

このコードを pso_example.py のような名前で保存し、コマンドライン（ターミナル）で python pso_example.py を実行すると、PSOが動作し、結果が表示されます。

実装のポイントと工夫

PSOを効果的に使うためには、いくつかのポイントや工夫があります。

パラメータ調整の勘所

PSOの性能は、パラメータ w, c1, c2 の設定に大きく影響されます。

慣性重み (w):
- 大きな値（例: 0.9）にすると、粒子は広範囲を探索しやすくなります（グローバルサーチ）。初期段階で有望な領域を大まかに見つけるのに役立ちます。
- 小さな値（例: 0.4）にすると、粒子は現在見つかっている良い解の周辺を重点的に探索します（ローカルサーチ）。収束の最終段階で解の精度を高めるのに役立ちます。
- 慣性重みをイテレーションが進むにつれて徐々に小さくしていく手法（線形減少慣性重みなど）もよく使われます。これにより、最初は広く探索し、徐々に絞り込んでいくというバランスの取れた探索が期待できます。
```
# イテレーションごとにwを線形に減少させる例
# w_start = 0.9
# w_end = 0.4
# w = w_start - (w_start - w_end) * (iteration / max_iterations)
```
加速係数 (c1, c2):
- c1（個人的ベストへの引力）が大きいと、粒子は自分の過去の成功体験に強く依存します。多様性が失われ、局所解に陥りやすくなる可能性がありますが、個々の粒子が良い解を見つけた場合にそれを深掘りする力になります。
- c2（全体ベストへの引力）が大きいと、粒子は群れ全体の情報に強く引かれます。収束は速くなる傾向がありますが、早すぎる収束は多様な解の探索を妨げる可能性があります。
- 一般的には c1 と c2 を同程度の値（例えば、c1 = c2 = 1.5 や c1 + c2 <= 4 程度）に設定することが多いですが、問題によって最適なバランスは異なります。
- c1 を徐々に小さくし、c2 を徐々に大きくする戦略なども考えられます。これは、探索の初期には個々の探索を重視し、後半には群れとしての知恵をより活用するアプローチです。

これらのパラメータは互いに影響し合うため、一つだけを変えても期待通りの結果にならないことがあります。問題の特性を考慮しながら、いくつかの組み合わせを試してみるのが良いでしょう。

初期値の設定方法

粒子の初期位置:
- 通常は探索空間内で一様にランダムに配置します。これにより、探索の初期段階で広い範囲をカバーできます。
- もし問題に関する事前知識があり、有望そうな領域が分かっている場合は、その周辺に粒子の一部を集中させることも有効な場合があります。ただし、偏りすぎると初期段階で局所解に引きずられるリスクもあります。
粒子の初期速度:
- 初期速度を0にする、あるいは非常に小さいランダムな値に設定するのが一般的です。大きな初期速度を与えると、粒子が初期段階で探索範囲を大きく逸脱してしまう可能性があります。
- 私たちの実装例では np.random.rand(num_particles, num_dimensions) * 0.1 としており、探索範囲の大きさに対して比較的小さな初期速度を与えています。

収束判定の仕方

max_iterations（最大繰り返し数）に達したら終了、というのが最も単純な停止条件です。しかし、それ以外にも以下のような収束判定の方法が考えられます。

評価値の改善が見られない: 一定回数のイテレーション（例えば、10〜20回）を経ても、全体ベストの評価値 (gbest_value) がほとんど改善しなくなった場合に収束したとみなして終了します。
```
# 評価値の改善度による収束判定の例 (疑似コード)
# if iteration > min_iterations and abs(history[-1] - history[-patience_count]) < tolerance:
#     print("収束しました。")
#     break
```
目標評価値の達成: もし達成したい評価値の目標が明確であれば、その値に達した時点で終了とすることもできます。
粒子のばらつき: 全ての粒子が非常に狭い範囲に収束し、それ以上探索が進まないと判断できる場合に終了します。粒子の位置の標準偏差などを監視する方法があります。

これらの条件を組み合わせることで、無駄な計算を避けつつ、十分な解の精度を得ることが期待できます。

より複雑な問題への応用（概念的な説明）

今回扱ったSphere関数は非常にシンプルな形状をしており、最適解も一つしかありません。しかし、実際の多くの問題はもっと複雑で、多数の「そこそこ良い解（局所最適解）」が存在し、その中から「本当に一番良い解（大域的最適解）」を見つけ出す必要があります。

制約条件の扱い: 多くの実問題では、「この値は0以上でなければならない」「これらの値の合計は100以内でなければならない」といった制約条件が付随します。PSOでこのような制約を扱うには、いくつかの方法があります。
1. ペナルティ関数法: 制約を破った粒子に対して、評価関数にペナルティ（罰則点）を加える方法です。制約違反の度合いが大きいほど大きなペナルティを与え、そのような解が選ばれにくくします。
2. 修復アルゴリズム: 粒子が制約を破る位置に移動した場合、強制的に制約を満たす位置に修正する方法です。
3. 探索範囲の限定: 粒子が制約を満たす範囲内でのみ移動するように、速度や位置の更新ルールを工夫する方法。
多峰性関数への対応: 最適解が複数あるような関数（多峰性関数、例えばRastrigin関数など）では、PSOが局所最適解に捕らわれやすくなります。これに対処するためには、
- 粒子の数を増やす。
- 慣性重み w を適切に設定し、探索と活用のバランスを取る。
- c1, c2 の値を調整して、多様性を維持する。
- ニッチ形成（複数の有望な領域を同時に探索する）や、クラスタリングを導入したPSOの亜種（例: Multi-swarm PSO）を利用する。
- ランダム性を高める（例えば、時折、一部の粒子をランダムに再初期化する）。

これらの工夫により、PSOはより幅広い種類の最適化問題に対応できるようになります。

まとめ

今回は、粒子群最適化（PSO）のアルゴリズムをPythonで実際に実装し、その動作の仕組みをステップバイステップで見てきました。シンプルな評価関数を使って、粒子たちがどのように協力し合って最適解を探し出すのかを体験していただけたかと思います。

PSOの強みは、アルゴリズムが比較的単純で実装しやすく、勾配情報（関数の微分）を必要としないため、複雑な形状を持つ関数や、微分不可能な関数に対しても適用できる点にあります。

実践編で学んだ主なポイントは以下の通りです。

粒子の位置と速度の更新メカニズム（慣性、個人的ベスト、全体ベストの影響）
主要なパラメータ（w, c1, c2）の役割と調整の勘所
評価関数、探索範囲、粒子数、繰り返し回数といった基本的な設定
収束の確認方法

もちろん、PSOは万能ではありません。問題の次元数が非常に大きい場合（数百次元以上など）や、非常に多くの局所最適解を持つ複雑な問題では、性能が低下したり、適切なパラメータを見つけるのが難しくなったりすることもあります。

しかし、そのシンプルさと柔軟性から、工学設計、機械学習のハイパーパラメータ調整、スケジューリング問題など、様々な分野で有効なツールとして利用されています。

この記事を通じて、PSOの基本的な実装方法と、その挙動をコントロールするためのパラメータの役割について理解を深めていただけたなら幸いです。ぜひ、ご自身で色々な関数やパラメータ設定を試して、PSOの動きを探求してみてください。

ゲームで学ぶ探索アルゴリズム実践入門～木探索とメタヒューリスティクス

探索技術とそれを支えるアルゴリズムにフォーカスを当て、ゲームAIを題材にその重要性と魅力を楽しく学ぶための入門書です。

▶ Amazonで見る

環境構築なしで
実行できるファイルはこちら！

このボタンからGoogle Colabを開き、すぐにコードをお試しいただけます。

Colabでコードを実行

お仕事のご依頼・ご相談はこちら

フロントエンドからバックエンドまで、アプリケーション開発のご相談を承っております。
まずはお気軽にご連絡ください。

プロフィールを見るお問い合わせはこちら

粒子群最適化（PSO）を実装してみよう！わかりやすく解説

はじめに

粒子群最適化（PSO）とは？（実践編のおさらい）

PSOをPythonで実装してみよう

準備するもの

評価関数（目的関数）の定義

PSOのメインロジックの実装

パラメータ設定

実行と結果の確認

コード全体の提示

実装のポイントと工夫

パラメータ調整の勘所

初期値の設定方法

収束判定の仕方

より複雑な問題への応用（概念的な説明）

まとめ

ゲームで学ぶ探索アルゴリズム実践入門～木探索とメタヒューリスティクス

環境構築なしで
実行できるファイルはこちら！

お仕事のご依頼・ご相談はこちら

関連する記事

主成分分析（PCA）を実装してみよう！わかりやすく解説

KAN (Kolmogorov-Arnold Networks)を実装してみよう！わかりやすく解説

畳み込みニューラルネットワーク（CNN）を実装してみよう！わかりやすく解説

ガウス過程回帰を実装してみよう！わかりやすく解説

ベイズ最適化を実装してみよう！わかりやすく解説

粒子群最適化（PSO）を実装してみよう！わかりやすく解説

はじめに

粒子群最適化（PSO）とは？（実践編のおさらい）

PSOをPythonで実装してみよう

準備するもの

評価関数（目的関数）の定義

PSOのメインロジックの実装

パラメータ設定

実行と結果の確認

コード全体の提示

実装のポイントと工夫

パラメータ調整の勘所

初期値の設定方法

収束判定の仕方

より複雑な問題への応用（概念的な説明）

まとめ

ゲームで学ぶ探索アルゴリズム実践入門～木探索とメタヒューリスティクス

環境構築なしで 実行できるファイルはこちら！

お仕事のご依頼・ご相談はこちら

関連する記事

主成分分析（PCA）を実装してみよう！わかりやすく解説

KAN (Kolmogorov-Arnold Networks)を実装してみよう！わかりやすく解説

畳み込みニューラルネットワーク（CNN）を実装してみよう！わかりやすく解説

ガウス過程回帰を実装してみよう！わかりやすく解説

ベイズ最適化を実装してみよう！わかりやすく解説

環境構築なしで
実行できるファイルはこちら！