4.1 Advanced Process Control (APC) の概要

4.1.1 APCの役割と重要性

半導体製造では、装置の経年劣化、環境変動、原材料のロット変動など、様々な外乱がプロセスに影響します。APCはこれらの外乱を補償し、目標値を安定維持する高度な制御システムです：

• 多変数制御: 複数の入力・出力を同時制御
• 予測制御: プロセスモデルで未来を予測し最適制御
• 適応制御: プロセス特性変化に自動対応
• 制約条件: 安全範囲・性能範囲を厳守

4.1.2 従来PID制御の限界

4.1.3 AIベースAPCの優位性

• 多目的最適化: 品質・コスト・スループットを同時最適化
• 学習能力: 過去データから制御則を自動学習
• ロバスト性: モデル誤差・外乱に強い
• リアルタイム性: GPU活用で高速計算

4.2 モデル予測制御 (MPC: Model Predictive Control)

4.2.1 MPCの原理

MPCは、プロセスモデルで未来の挙動を予測し、性能指標を最小化する制御入力系列を計算します：

4.2.2 CVDプロセスMPC実装

Chemical Vapor Deposition (CVD) における膜厚制御をMPCで実現します：

import numpy as np
from scipy.optimize import minimize
import matplotlib.pyplot as plt

class ModelPredictiveController:
    """
    モデル予測制御 (MPC) for CVDプロセス

    制御目標: 膜厚を目標値に追従
    制御変数: ガス流量、RFパワー、圧力
    状態変数: 膜厚、成膜速度
    """

    def __init__(self, prediction_horizon=10, control_horizon=5, dt=1.0):
        """
        Parameters:
        -----------
        prediction_horizon : int
            予測ホライズン N
        control_horizon : int
            制御ホライズン M (M ≤ N)
        dt : float
            サンプリング時間 (秒)
        """
        self.N = prediction_horizon
        self.M = control_horizon
        self.dt = dt

        # 状態空間モデルのパラメータ
        # x = [膜厚 (nm), 成膜速度 (nm/s)]
        # u = [ガス流量 (sccm), RFパワー (W), 圧力 (mTorr)]
        self.A = np.array([
            [1, self.dt],
            [0, 0.95]
        ])

        self.B = np.array([
            [0, 0, 0],
            [0.01, 0.02, -0.005]
        ])

        # 出力行列 (膜厚のみ観測)
        self.C = np.array([[1, 0]])

        # 重み行列
        self.Q = np.diag([100, 1])  # 状態コスト
        self.R = np.diag([0.1, 0.1, 0.1])  # 制御入力コスト

        # 制約条件
        self.u_min = np.array([50, 100, 10])
        self.u_max = np.array([200, 400, 100])
        self.y_min = 0
        self.y_max = 200  # 膜厚上限 (nm)

    def predict(self, x0, u_sequence):
        """
        状態予測

        Parameters:
        -----------
        x0 : ndarray
            初期状態 (2,)
        u_sequence : ndarray
            制御入力系列 (M, 3)

        Returns:
        --------
        x_pred : ndarray
            予測状態軌道 (N+1, 2)
        y_pred : ndarray
            予測出力軌道 (N+1,)
        """
        x_pred = np.zeros((self.N + 1, 2))
        y_pred = np.zeros(self.N + 1)

        x_pred[0] = x0
        y_pred[0] = self.C @ x0

        for k in range(self.N):
            if k < self.M:
                u_k = u_sequence[k]
            else:
                # 制御ホライズン以降は最後の入力を保持
                u_k = u_sequence[self.M - 1]

            # 状態遷移
            x_pred[k + 1] = self.A @ x_pred[k] + self.B @ u_k
            y_pred[k + 1] = self.C @ x_pred[k + 1]

        return x_pred, y_pred

    def cost_function(self, u_flat, x0, r_sequence):
        """
        コスト関数

        Parameters:
        -----------
        u_flat : ndarray
            平坦化された制御入力系列 (M*3,)
        x0 : ndarray
            現在状態
        r_sequence : ndarray
            目標値系列 (N+1,)
        """
        # 制御入力を復元
        u_sequence = u_flat.reshape((self.M, 3))

        # 予測
        x_pred, y_pred = self.predict(x0, u_sequence)

        # コスト計算
        cost = 0.0

        # トラッキング誤差
        for k in range(self.N + 1):
            error = y_pred[k] - r_sequence[k]
            cost += error ** 2 * self.Q[0, 0]

        # 制御入力コスト
        for k in range(self.M):
            cost += u_sequence[k] @ self.R @ u_sequence[k]

        # 制御入力変化コスト (滑らかな制御)
        for k in range(1, self.M):
            du = u_sequence[k] - u_sequence[k - 1]
            cost += 0.1 * (du @ du)

        return cost

    def solve_mpc(self, x0, r_sequence, u_prev):
        """
        MPC最適化問題を解く

        Parameters:
        -----------
        x0 : ndarray
            現在状態
        r_sequence : ndarray
            目標値系列 (N+1,)
        u_prev : ndarray
            前時刻の制御入力 (3,)

        Returns:
        --------
        u_opt : ndarray
            最適制御入力 (3,)
        """
        # 初期推定値 (前時刻の入力を保持)
        u0 = np.tile(u_prev, self.M)

        # 制約条件
        bounds = []
        for _ in range(self.M):
            for i in range(3):
                bounds.append((self.u_min[i], self.u_max[i]))

        # 最適化
        result = minimize(
            fun=lambda u: self.cost_function(u, x0, r_sequence),
            x0=u0,
            method='SLSQP',
            bounds=bounds,
            options={'maxiter': 100, 'ftol': 1e-6}
        )

        # 最適制御入力 (最初のステップのみ使用)
        u_opt_sequence = result.x.reshape((self.M, 3))
        u_opt = u_opt_sequence[0]

        return u_opt

    def simulate_closed_loop(self, x0, r_trajectory, n_steps):
        """
        閉ループシミュレーション

        Parameters:
        -----------
        x0 : ndarray
            初期状態
        r_trajectory : ndarray
            目標値軌道 (n_steps,)
        n_steps : int
            シミュレーションステップ数

        Returns:
        --------
        results : dict
            シミュレーション結果
        """
        # 履歴保存
        x_history = np.zeros((n_steps + 1, 2))
        y_history = np.zeros(n_steps + 1)
        u_history = np.zeros((n_steps, 3))
        r_history = np.zeros(n_steps + 1)

        x_history[0] = x0
        y_history[0] = self.C @ x0
        r_history[0] = r_trajectory[0]

        u_prev = np.array([125, 250, 55])  # 初期制御入力

        for k in range(n_steps):
            # 目標値系列 (予測ホライズン分)
            r_sequence = np.zeros(self.N + 1)
            for i in range(self.N + 1):
                if k + i < n_steps:
                    r_sequence[i] = r_trajectory[k + i]
                else:
                    r_sequence[i] = r_trajectory[-1]

            # MPC最適化
            u_opt = self.solve_mpc(x_history[k], r_sequence, u_prev)
            u_history[k] = u_opt

            # プロセスに適用 (実際のプロセスには外乱が含まれる)
            noise = np.random.normal(0, 0.1, 2)  # プロセスノイズ
            x_history[k + 1] = self.A @ x_history[k] + self.B @ u_opt + noise
            y_history[k + 1] = self.C @ x_history[k + 1]
            r_history[k + 1] = r_trajectory[k + 1] if k + 1 < n_steps else r_trajectory[-1]

            u_prev = u_opt

        results = {
            'x': x_history,
            'y': y_history,
            'u': u_history,
            'r': r_history,
            'time': np.arange(n_steps + 1) * self.dt
        }

        return results

    def plot_results(self, results):
        """結果の可視化"""
        fig, axes = plt.subplots(2, 2, figsize=(14, 10))

        time = results['time']
        y = results['y']
        r = results['r']
        u = results['u']

        # 膜厚トラッキング
        axes[0, 0].plot(time, y, 'b-', linewidth=2, label='Actual Thickness')
        axes[0, 0].plot(time, r, 'r--', linewidth=2, label='Target Thickness')
        axes[0, 0].set_xlabel('Time (s)')
        axes[0, 0].set_ylabel('Thickness (nm)')
        axes[0, 0].set_title('Film Thickness Tracking')
        axes[0, 0].legend()
        axes[0, 0].grid(True, alpha=0.3)

        # トラッキング誤差
        error = y - r
        axes[0, 1].plot(time, error, 'g-', linewidth=2)
        axes[0, 1].axhline(0, color='k', linestyle='--', alpha=0.3)
        axes[0, 1].set_xlabel('Time (s)')
        axes[0, 1].set_ylabel('Error (nm)')
        axes[0, 1].set_title('Tracking Error')
        axes[0, 1].grid(True, alpha=0.3)

        # 制御入力
        axes[1, 0].plot(time[:-1], u[:, 0], label='Gas Flow (sccm)')
        axes[1, 0].plot(time[:-1], u[:, 1], label='RF Power (W)')
        axes[1, 0].set_xlabel('Time (s)')
        axes[1, 0].set_ylabel('Control Input')
        axes[1, 0].set_title('Control Inputs (Gas & RF)')
        axes[1, 0].legend()
        axes[1, 0].grid(True, alpha=0.3)

        axes[1, 1].plot(time[:-1], u[:, 2], 'purple', label='Pressure (mTorr)')
        axes[1, 1].set_xlabel('Time (s)')
        axes[1, 1].set_ylabel('Pressure (mTorr)')
        axes[1, 1].set_title('Control Input (Pressure)')
        axes[1, 1].legend()
        axes[1, 1].grid(True, alpha=0.3)

        plt.tight_layout()
        plt.savefig('mpc_control_results.png', dpi=300, bbox_inches='tight')
        plt.show()


# ========== 使用例 ==========
if __name__ == "__main__":
    np.random.seed(42)

    # MPC設定
    mpc = ModelPredictiveController(
        prediction_horizon=10,
        control_horizon=5,
        dt=1.0
    )

    # 初期状態 [膜厚, 成膜速度]
    x0 = np.array([0.0, 0.0])

    # 目標値軌道 (ステップ応答 + ランプ)
    n_steps = 100
    r_trajectory = np.zeros(n_steps)
    r_trajectory[:30] = 50  # 50nm
    r_trajectory[30:60] = 100  # 100nm
    r_trajectory[60:] = np.linspace(100, 150, 40)  # ランプ

    # 閉ループシミュレーション
    print("========== MPC Closed-Loop Simulation ==========")
    results = mpc.simulate_closed_loop(x0, r_trajectory, n_steps)

    # 性能評価
    tracking_error = results['y'] - results['r']
    mae = np.mean(np.abs(tracking_error))
    rmse = np.sqrt(np.mean(tracking_error ** 2))

    print(f"\nTracking Performance:")
    print(f"  MAE (Mean Absolute Error): {mae:.4f} nm")
    print(f"  RMSE (Root Mean Squared Error): {rmse:.4f} nm")

    # 制御入力の統計
    print(f"\nControl Input Statistics:")
    print(f"  Gas Flow: {np.mean(results['u'][:, 0]):.2f} ± {np.std(results['u'][:, 0]):.2f} sccm")
    print(f"  RF Power: {np.mean(results['u'][:, 1]):.2f} ± {np.std(results['u'][:, 1]):.2f} W")
    print(f"  Pressure: {np.mean(results['u'][:, 2]):.2f} ± {np.std(results['u'][:, 2]):.2f} mTorr")

    # 可視化
    mpc.plot_results(results)

4.2.3 非線形MPCとNeural Network Model

複雑な非線形プロセスに対しては、ニューラルネットワークをプロセスモデルとして使用します：

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

class NeuralNetworkMPC:
    """
    Neural Network-based MPC

    複雑な非線形プロセスをNNでモデル化し、
    勾配法でMPC最適化を実行
    """

    def __init__(self, state_dim=2, control_dim=3, prediction_horizon=10):
        """
        Parameters:
        -----------
        state_dim : int
            状態次元
        control_dim : int
            制御入力次元
        prediction_horizon : int
            予測ホライズン
        """
        self.state_dim = state_dim
        self.control_dim = control_dim
        self.N = prediction_horizon

        # Neural Network Process Model
        self.process_model = self._build_process_model()

    def _build_process_model(self):
        """
        プロセスモデルNN構築

        入力: [x_k, u_k] (concat)
        出力: x_{k+1}
        """
        inputs = layers.Input(shape=(self.state_dim + self.control_dim,))

        x = layers.Dense(64, activation='relu')(inputs)
        x = layers.BatchNormalization()(x)
        x = layers.Dense(64, activation='relu')(x)
        x = layers.BatchNormalization()(x)
        x = layers.Dense(32, activation='relu')(x)

        outputs = layers.Dense(self.state_dim)(x)

        model = keras.Model(inputs, outputs, name='process_model')
        model.compile(optimizer='adam', loss='mse')

        return model

    def train_process_model(self, X_train, y_train, epochs=50):
        """
        プロセスモデルの訓練

        Parameters:
        -----------
        X_train : ndarray
            [x_k, u_k] の訓練データ (N, state_dim + control_dim)
        y_train : ndarray
            x_{k+1} のラベル (N, state_dim)
        """
        history = self.process_model.fit(
            X_train, y_train,
            validation_split=0.2,
            epochs=epochs,
            batch_size=32,
            verbose=0
        )

        return history

    def predict_trajectory(self, x0, u_sequence):
        """
        NN process modelで軌道予測

        Parameters:
        -----------
        x0 : ndarray
            初期状態 (state_dim,)
        u_sequence : ndarray
            制御入力系列 (N, control_dim)

        Returns:
        --------
        x_trajectory : ndarray
            予測状態軌道 (N+1, state_dim)
        """
        x_trajectory = np.zeros((self.N + 1, self.state_dim))
        x_trajectory[0] = x0

        for k in range(self.N):
            xu_k = np.concatenate([x_trajectory[k], u_sequence[k]]).reshape(1, -1)
            x_trajectory[k + 1] = self.process_model.predict(xu_k, verbose=0)[0]

        return x_trajectory

    def mpc_optimization(self, x0, r_sequence):
        """
        TensorFlowの自動微分でMPC最適化

        Parameters:
        -----------
        x0 : ndarray
            現在状態
        r_sequence : ndarray
            目標値系列 (N+1,)

        Returns:
        --------
        u_opt : ndarray
            最適制御入力系列 (N, control_dim)
        """
        # 初期制御入力
        u_var = tf.Variable(
            np.random.uniform(50, 200, (self.N, self.control_dim)),
            dtype=tf.float32
        )

        optimizer = tf.keras.optimizers.Adam(learning_rate=0.1)

        # 最適化ループ
        for iteration in range(50):
            with tf.GradientTape() as tape:
                # 予測
                x_pred = tf.constant(x0, dtype=tf.float32)
                cost = 0.0

                for k in range(self.N):
                    # 状態遷移
                    xu_k = tf.concat([x_pred, u_var[k]], axis=0)
                    xu_k = tf.reshape(xu_k, (1, -1))
                    x_pred = self.process_model(xu_k, training=False)[0]

                    # トラッキング誤差コスト
                    error = x_pred[0] - r_sequence[k + 1]  # 膜厚誤差
                    cost += 100 * error ** 2

                    # 制御入力コスト
                    cost += 0.01 * tf.reduce_sum(u_var[k] ** 2)

            # 勾配計算・更新
            gradients = tape.gradient(cost, [u_var])
            optimizer.apply_gradients(zip(gradients, [u_var]))

        u_opt = u_var.numpy()

        return u_opt


# ========== 使用例 ==========
# プロセスモデル訓練用のダミーデータ生成
np.random.seed(42)
n_samples = 5000

X_train = np.random.randn(n_samples, 5)  # [x1, x2, u1, u2, u3]
# ダミーの非線形プロセス
y_train = np.zeros((n_samples, 2))
y_train[:, 0] = X_train[:, 0] + 0.1 * X_train[:, 2] + 0.02 * X_train[:, 3]
y_train[:, 1] = 0.95 * X_train[:, 1] + 0.01 * X_train[:, 2]

# NN-MPC構築・訓練
nn_mpc = NeuralNetworkMPC(state_dim=2, control_dim=3, prediction_horizon=10)
print("\n========== Training NN Process Model ==========")
history = nn_mpc.train_process_model(X_train, y_train, epochs=30)

print(f"Training Loss: {history.history['loss'][-1]:.6f}")
print(f"Validation Loss: {history.history['val_loss'][-1]:.6f}")

# MPC最適化
x0_nn = np.array([0.0, 0.0])
r_sequence_nn = np.full(11, 100.0)

print("\n========== NN-MPC Optimization ==========")
u_opt_nn = nn_mpc.mpc_optimization(x0_nn, r_sequence_nn)

print(f"Optimal Control Sequence (first 3 steps):")
for k in range(3):
    print(f"  Step {k}: u = {u_opt_nn[k]}")

4.3 強化学習による制御器学習

4.3.1 強化学習APCの概念

強化学習 (Reinforcement Learning, RL) は、試行錯誤を通じて最適な制御則を学習します：

• モデルフリー: プロセスモデル不要（実データから直接学習）
• 適応性: プロセス変化に自動適応
• 最適性: 長期的な報酬を最大化
• 非線形制御: 複雑な非線形プロセスに対応

4.3.2 DQN (Deep Q-Network) による離散制御

離散的な制御アクション (例: パワーレベル Low/Medium/High) の選択をDQNで学習します：

import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from collections import deque
import random

class DQNController:
    """
    DQN (Deep Q-Network) による制御器

    CVDプロセスの離散制御を学習
    アクション: ガス流量・RFパワー・圧力の増減
    """

    def __init__(self, state_dim=4, action_dim=27, learning_rate=0.001):
        """
        Parameters:
        -----------
        state_dim : int
            状態次元 [膜厚, 成膜速度, 目標膜厚, 誤差]
        action_dim : int
            アクション数 (3変数 × 3レベル = 27通り)
        """
        self.state_dim = state_dim
        self.action_dim = action_dim
        self.learning_rate = learning_rate

        # ハイパーパラメータ
        self.gamma = 0.99  # 割引率
        self.epsilon = 1.0  # ε-greedy初期値
        self.epsilon_min = 0.01
        self.epsilon_decay = 0.995
        self.batch_size = 64
        self.memory = deque(maxlen=10000)

        # Q-Network
        self.q_network = self._build_network()
        self.target_network = self._build_network()
        self.update_target_network()

    def _build_network(self):
        """Q-Network構築"""
        inputs = layers.Input(shape=(self.state_dim,))

        x = layers.Dense(128, activation='relu')(inputs)
        x = layers.Dense(128, activation='relu')(x)
        x = layers.Dense(64, activation='relu')(x)

        # Q値出力 (各アクションのQ値)
        q_values = layers.Dense(self.action_dim, activation='linear')(x)

        model = keras.Model(inputs, q_values)
        model.compile(
            optimizer=keras.optimizers.Adam(learning_rate=self.learning_rate),
            loss='mse'
        )

        return model

    def update_target_network(self):
        """Target Networkの重みを更新"""
        self.target_network.set_weights(self.q_network.get_weights())

    def select_action(self, state):
        """
        ε-greedy方策でアクション選択

        Parameters:
        -----------
        state : ndarray
            現在状態 (state_dim,)

        Returns:
        --------
        action : int
            選択されたアクション (0 ~ action_dim-1)
        """
        if np.random.rand() < self.epsilon:
            # ランダムアクション (探索)
            return np.random.randint(self.action_dim)
        else:
            # Q値最大のアクション (活用)
            q_values = self.q_network.predict(state.reshape(1, -1), verbose=0)[0]
            return np.argmax(q_values)

    def remember(self, state, action, reward, next_state, done):
        """経験をメモリに保存"""
        self.memory.append((state, action, reward, next_state, done))

    def replay(self):
        """
        Experience Replayで学習

        メモリからランダムサンプリングしてQ-Networkを更新
        """
        if len(self.memory) < self.batch_size:
            return

        # ミニバッチサンプリング
        minibatch = random.sample(self.memory, self.batch_size)

        states = np.array([exp[0] for exp in minibatch])
        actions = np.array([exp[1] for exp in minibatch])
        rewards = np.array([exp[2] for exp in minibatch])
        next_states = np.array([exp[3] for exp in minibatch])
        dones = np.array([exp[4] for exp in minibatch])

        # 現在のQ値
        q_values = self.q_network.predict(states, verbose=0)

        # Target Q値 (Double DQN)
        next_q_values = self.target_network.predict(next_states, verbose=0)

        # Bellman更新
        for i in range(self.batch_size):
            if dones[i]:
                q_values[i, actions[i]] = rewards[i]
            else:
                q_values[i, actions[i]] = (
                    rewards[i] + self.gamma * np.max(next_q_values[i])
                )

        # Q-Network訓練
        self.q_network.fit(states, q_values, epochs=1, verbose=0)

        # εの減衰
        if self.epsilon > self.epsilon_min:
            self.epsilon *= self.epsilon_decay

    def action_to_control(self, action):
        """
        アクション番号を制御入力に変換

        アクション: 0-26 (3^3 = 27通り)
        各変数: 0=減少, 1=維持, 2=増加
        """
        # 3進数展開
        gas_action = action // 9
        rf_action = (action % 9) // 3
        pressure_action = action % 3

        # 制御量変換
        gas_delta = (gas_action - 1) * 10  # ±10 sccm
        rf_delta = (rf_action - 1) * 20  # ±20 W
        pressure_delta = (pressure_action - 1) * 5  # ±5 mTorr

        return np.array([gas_delta, rf_delta, pressure_delta])


class CVDEnvironment:
    """CVDプロセス環境 (RL用)"""

    def __init__(self, target_thickness=100):
        self.target_thickness = target_thickness
        self.reset()

    def reset(self):
        """環境リセット"""
        self.thickness = 0.0
        self.rate = 0.0
        self.gas_flow = 125
        self.rf_power = 250
        self.pressure = 55
        self.step_count = 0

        return self._get_state()

    def _get_state(self):
        """状態取得"""
        error = self.target_thickness - self.thickness
        return np.array([self.thickness, self.rate, self.target_thickness, error])

    def step(self, action_delta):
        """
        1ステップ実行

        Parameters:
        -----------
        action_delta : ndarray
            制御量変化 [Δgas, ΔRF, Δpressure]

        Returns:
        --------
        next_state : ndarray
        reward : float
        done : bool
        """
        # 制御入力更新
        self.gas_flow = np.clip(self.gas_flow + action_delta[0], 50, 200)
        self.rf_power = np.clip(self.rf_power + action_delta[1], 100, 400)
        self.pressure = np.clip(self.pressure + action_delta[2], 10, 100)

        # プロセスシミュレーション (簡易モデル)
        self.rate = (
            0.01 * self.gas_flow + 0.02 * self.rf_power - 0.005 * self.pressure
        ) / 10
        self.thickness += self.rate + np.random.normal(0, 0.1)

        # 報酬設計
        error = abs(self.target_thickness - self.thickness)

        if error < 1:
            reward = 10  # 目標達成
        elif error < 5:
            reward = 5 - error
        else:
            reward = -error / 10

        # 終了判定
        self.step_count += 1
        done = (self.step_count >= 50) or (error < 1)

        next_state = self._get_state()

        return next_state, reward, done


# ========== DQN訓練 ==========
if __name__ == "__main__":
    np.random.seed(42)
    random.seed(42)
    tf.random.set_seed(42)

    env = CVDEnvironment(target_thickness=100)
    agent = DQNController(state_dim=4, action_dim=27, learning_rate=0.001)

    print("========== DQN Training ==========")
    episodes = 200
    target_update_freq = 10

    episode_rewards = []

    for episode in range(episodes):
        state = env.reset()
        total_reward = 0

        for step in range(50):
            # アクション選択
            action = agent.select_action(state)
            action_delta = agent.action_to_control(action)

            # 環境ステップ
            next_state, reward, done = env.step(action_delta)
            total_reward += reward

            # 経験保存
            agent.remember(state, action, reward, next_state, done)

            # 学習
            agent.replay()

            state = next_state

            if done:
                break

        episode_rewards.append(total_reward)

        # Target Network更新
        if episode % target_update_freq == 0:
            agent.update_target_network()

        # 進捗表示
        if (episode + 1) % 20 == 0:
            avg_reward = np.mean(episode_rewards[-20:])
            print(f"Episode {episode+1}/{episodes}: "
                  f"Avg Reward (last 20) = {avg_reward:.2f}, "
                  f"ε = {agent.epsilon:.3f}")

    print("\n========== Training Complete ==========")

    # 学習曲線
    plt.figure(figsize=(10, 6))
    plt.plot(episode_rewards, alpha=0.3)
    plt.plot(np.convolve(episode_rewards, np.ones(20)/20, mode='valid'),
             linewidth=2, label='Moving Average (20 episodes)')
    plt.xlabel('Episode')
    plt.ylabel('Total Reward')
    plt.title('DQN Learning Curve')
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.savefig('dqn_learning_curve.png', dpi=300, bbox_inches='tight')
    plt.show()

    print(f"Final ε: {agent.epsilon:.4f}")
    print(f"Final Average Reward (last 20 episodes): "
          f"{np.mean(episode_rewards[-20:]):.2f}")

4.4 まとめ

本章では、Advanced Process Control (APC) のAI実装手法を学習しました：

次章への展開

第5章「Fault Detection & Classification (FDC)」では、プロセス異常の早期検知と診断手法を学びます：

• Multivariate Statistical Process Control (MSPC)
• Isolation Forestによる異常検知
• Deep Learningによる故障診断分類
• Root Cause Analysis (RCA) で原因特定