1️⃣ 시스템 모델 정의하기

먼저 제어하려는 시스템의 동역학을 수학적으로 모델링해야 해요. 간단한 예로 DC 모터 모델을 정의해볼게요:

import numpy as np

# 선형 시스템 모델 정의 (DC 모터 예시)
class DCMotorModel:
    def __init__(self):
        # 시스템 매트릭스
        self.A = np.array([[0.9, 0.2], 
                           [-0.1, 0.8]])  # 상태 전이 행렬
        self.B = np.array([[0.1], 
                           [0.5]])  # 입력 행렬
        self.C = np.array([[1.0, 0.0]])  # 출력 행렬
        
    def step(self, x, u):
        """한 스텝 진행 후 다음 상태 계산"""
        return self.A @ x + self.B * u
    
    def output(self, x):
        """현재 상태에서 출력 계산"""
        return self.C @ x
      

이 코드는 간단한 DC 모터의 동역학을 표현해요. 실제 모터의 각도와 각속도가 어떻게 변하는지 모델링한 거죠. A, B, C 행렬이 시스템의 특성을 결정해요! 🔄

2️⃣ 예측 모델 구현하기

이제 미래 상태를 예측하는 모델을 구현해볼게요:

class MPCPredictor:
    def __init__(self, model, prediction_horizon):
        self.model = model
        self.N = prediction_horizon  # 예측 지평선
        
    def predict(self, x0, u_sequence):
        """주어진 초기 상태와 제어 입력 시퀀스에 대한 미래 상태 예측"""
        x = np.copy(x0)
        x_trajectory = [x]
        y_trajectory = [self.model.output(x)]
        
        for i in range(self.N):
            # 현재 제어 입력으로 다음 상태 계산
            if i < len(u_sequence):
                u = u_sequence[i]
            else:
                u = 0  # 제어 입력이 없으면 0으로 가정
                
            x = self.model.step(x, u)
            y = self.model.output(x)
            
            x_trajectory.append(x)
            y_trajectory.append(y)
            
        return np.array(x_trajectory), np.array(y_trajectory)
      

이 예측 모델은 초기 상태와 제어 입력 시퀀스가 주어지면 미래 상태를 예측해요. 마치 "이렇게 움직이면 어떻게 될까?"를 시뮬레이션하는 거죠! 🔮

3️⃣ 비용 함수 설계하기

이제 어떤 제어 전략이 '좋은지' 평가하는 비용 함수를 설계해요:

class MPCCostFunction:
    def __init__(self, Q, R):
        self.Q = Q  # 상태 오차 가중치
        self.R = R  # 제어 입력 가중치
        
    def compute_cost(self, y_trajectory, u_sequence, reference):
        """비용 함수 계산: 추적 오차와 제어 노력의 가중합"""
        cost = 0
        
        # 추적 오차 비용
        for i in range(len(y_trajectory)):
            error = y_trajectory[i] - reference
            cost += error @ self.Q @ error.T
            
        # 제어 노력 비용
        for i in range(len(u_sequence)):
            cost += u_sequence[i] * self.R * u_sequence[i]
            
        return cost
      

비용 함수는 두 가지 요소의 균형을 맞춰요:

1. 추적 오차: 목표값에 얼마나 가까운지 (Q로 가중치 부여)
2. 제어 노력: 제어 입력이 얼마나 크고 급격한지 (R로 가중치 부여)

Q와 R의 값을 조절하면 시스템의 응답 특성을 미세 조정할 수 있어요. 마치 게임에서 캐릭터의 민첩성과 파워 사이의 밸런스를 맞추는 것과 비슷하죠! ⚖️

4️⃣ 최적화 문제 해결하기

이제 최적의 제어 입력을 찾기 위한 최적화 알고리즘을 구현해요:

from scipy.optimize import minimize

class MPCOptimizer:
    def __init__(self, predictor, cost_function, control_horizon):
        self.predictor = predictor
        self.cost_function = cost_function
        self.Nc = control_horizon  # 제어 지평선
        
    def objective(self, u_flat, x0, reference):
        """최적화 알고리즘을 위한 목적 함수"""
        # 1차원 배열을 제어 시퀀스로 변환
        u_sequence = u_flat.reshape(self.Nc, 1)
        
        # 미래 상태 예측
        _, y_trajectory = self.predictor.predict(x0, u_sequence)
        
        # 비용 계산
        cost = self.cost_function.compute_cost(y_trajectory, u_sequence, reference)
        
        return cost
        
    def optimize(self, x0, reference, u_init=None, bounds=None):
        """최적의 제어 입력 시퀀스 계산"""
        if u_init is None:
            u_init = np.zeros(self.Nc)
            
        # 최적화 문제 해결
        result = minimize(
            self.objective,
            u_init,
            args=(x0, reference),
            method='SLSQP',
            bounds=bounds
        )
        
        # 최적의 제어 시퀀스 반환
        u_optimal = result.x.reshape(self.Nc, 1)
        return u_optimal
      

여기서는 SciPy의 minimize 함수를 사용해 최적화 문제를 풀어요. 이 과정에서 여러 가능한 제어 시퀀스 중에서 비용이 가장 낮은 것을 찾아내죠! 🔍

실제로는 더 효율적인 최적화 알고리즘이나 QP(Quadratic Programming) 솔버를 사용하는 경우가 많아요. 특히 실시간 제어가 필요한 경우에는 계산 효율성이 중요하니까요! ⏱️

5️⃣ 제어 루프 구현하기

마지막으로, 모든 요소를 조합해 전체 MPC 제어 루프를 구현해요:

class ModelPredictiveController:
    def __init__(self, model, prediction_horizon, control_horizon, Q, R):
        self.model = model
        self.predictor = MPCPredictor(model, prediction_horizon)
        self.cost_function = MPCCostFunction(Q, R)
        self.optimizer = MPCOptimizer(self.predictor, self.cost_function, control_horizon)
        
        # 제약 조건 설정 (입력 제한)
        self.input_bounds = [(-1.0, 1.0)] * control_horizon  # -1.0 ~ 1.0 사이로 제한
        
    def control(self, x_current, reference):
        """현재 상태에서 최적의 제어 입력 계산"""
        # 최적의 제어 시퀀스 계산
        u_sequence = self.optimizer.optimize(
            x_current, 
            reference, 
            bounds=self.input_bounds
        )
        
        # 첫 번째 제어 입력만 적용 (리세딩 호라이즌 원칙)
        u_applied = u_sequence[0]
        
        return u_applied

# MPC 컨트롤러 생성 및 사용 예시
if __name__ == "__main__":
    # 시스템 모델 생성
    motor_model = DCMotorModel()
    
    # MPC 파라미터 설정
    prediction_horizon = 10
    control_horizon = 5
    Q = np.array([[1.0]])  # 출력 오차 가중치
    R = 0.1  # 제어 입력 가중치
    
    # MPC 컨트롤러 생성
    mpc = ModelPredictiveController(
        motor_model, 
        prediction_horizon, 
        control_horizon, 
        Q, R
    )
    
    # 시뮬레이션 설정
    x = np.array([[0.0], [0.0]])  # 초기 상태
    reference = 1.0  # 목표값
    sim_steps = 50
    
    # 시뮬레이션 실행
    x_history = [x[0, 0]]
    u_history = []
    
    for i in range(sim_steps):
        # 제어 입력 계산
        u = mpc.control(x, reference)
        u_history.append(u[0])
        
        # 시스템 한 스텝 진행
        x = motor_model.step(x, u)
        x_history.append(x[0, 0])
        
    # 결과 시각화 (matplotlib 필요)
    import matplotlib.pyplot as plt
    
    plt.figure(figsize=(12, 6))
    
    plt.subplot(2, 1, 1)
    plt.plot(range(sim_steps + 1), x_history, 'b-', label='Motor Position')
    plt.plot([0, sim_steps], [reference, reference], 'r--', label='Reference')
    plt.legend()
    plt.title('MPC Control of DC Motor')
    
    plt.subplot(2, 1, 2)
    plt.plot(range(sim_steps), u_history, 'g-', label='Control Input')
    plt.legend()
    plt.xlabel('Time Step')
    
    plt.tight_layout()
    plt.show()
      

이 코드는 전체 MPC 제어 루프를 구현하고 간단한 시뮬레이션을 실행해요. 핵심은 매 스텝마다 최적화 문제를 풀고, 첫 번째 제어 입력만 적용하는 것이에요. 이를 '리세딩 호라이즌(receding horizon)' 원칙이라고 해요! 🔄