제어 이론은 인공지능 의료 기기의 핵심 수학적 기반이며, 인슐린 펌프의 자동 혈당 조절부터 수술 로봇의 정밀 위치 제어까지 폭넓게 적용된다. 이 글에서는 제어 이론의 핵심 개념을 살펴보고, 인슐린 펌프 폐루 제어를 중심으로 이론이 실제 의료 현장에 어떻게 적용되는지 알아본다.

제어 시스템의 기본 구조

개루 제어와 폐루 제어

개루 제어(Open-loop)는 출력이 입력에만 의존하며, 시스템의 실제 출력을 측정하여 보정하지 않는 방식이다. 반면 폐루 제어(Closed-loop)는 출력을 피드백하여 입력과 비교한 오차를 바탕으로 제어 신호를 생성한다.

폐루 제어의 핵심 수식은 다음과 같다:

e(t) = r(t) - y(t)
u(t) = f(e(t))

여기서 r(t)는 목표값, y(t)는 실제 출력, e(t)는 오차, u(t)는 제어 입력이다.

성능 평가 지표

지표	정의	의료 적용
안정성	유계 입력에 대해 유계 출력 보장	환자 안전 필수 조건
정상 오차	목표값과의 최종 편차	목표 혈당 도달 정도
상승 시간	10% → 90% 도달 시간	응급 처치 반응 속도
오버슈트	최대값 대비 초과 비율	저혈당/고혈당 리스크
안정화 시간	±5% 오차대 진입 시간	치료 효과 발현 시간

전달함수와 상태공간 표현

전달함수

선형 시불변 시스템에서 전달함수 G(s)는 출력의 라플라스 변환을 입력의 라플라스 변환으로 나눈 값이다:

G(s) = Y(s)/U(s)

의료 분야에서 자주 마주치는 동태적 요소들:

요소 유형	전달함수	임상 사례
비례	G(s) = K	센서 증폭
적분	G(s) = 1/(Ts)	약물 누적 효과
미분	G(s) = Ts	신호 필터링
관성	G(s) = K/(Ts+1)	혈당 반응
진동	G(s) = Kωₙ²/(s² + 2ζωₙs + ωₙ²)	기계적 공진

상태공간 모델

다변수 시스템을 다룰 때는 상태공간 표현이 유리하다:

ẋ(t) = A·x(t) + B·u(t)
y(t) = C·x(t) + D·u(t)

약물 대사를 예로 들면, 중앙실 도 c₁과 주변실 농도 c₂를 상태변수로 하는 이실 모델을 구성할 수 있다:

d/dt [c₁] = [-k₁   0  ][c₁] + [1/V₁] u
     [c₂]   [ k₁  -k₂][c₂]   [  0 ]

안정성 분석: 리아푸노프 방법

리아푸노프 안정성 정의

자율 시스템 ẋ = f(x)의 평형점 xₑ에 대해:

• 안정: 임의의 ε > 0에 대해 δ > 0가 존재하여, ‖x(0) - xₑ‖ < δ이면 모든 t ≥ 0에서 ‖x(t) - xₑ‖ < ε
• 점근 안정: 안정이면서 t → ∞일 때 x(t) → xₑ
• 전역 점근 안정: 임의의 초기조건에서 점근 안정

리아푸노프 직접법

함수 V(x)가 다음을 만족하면 평형점은 점근 안정이다:

1. V(0) = 0이고 x ≠ 0일 때 V(x) > 0 (양정성)
2. V̇(x) = ∇Vᵀ·f(x) < 0 (미분 음정성)

선형 시스템 ẋ = Ax에 대해, V(x) = xᵀPx 형태를 가정하면 리아푸노프 방정식을 얻는다:

AᵀP + PA = -Q

임의의 양정행렬 Q에 대해 이 방정식의 해 P가 양정이면 시스템은 점근 안정이다.

의료 적용: 인슐린 펌프 폐루 제어

혈당 동태 모델

버그만 최소 모델(Bergman Minimal Model)을 기반으로 한 혈당-인슐린 상호작용:

dG/dt = -p₁G - X(G - Gb) + Ra/Vg
dX/dt = -p₂X + p₃I
dI/dt = -nI + u/Vi + γ[G - Gth]⁺

여기서 G는 혈당 농도, X는 인슐인 작용 변수, I는 혈장 인슐린 농도, u는 외부 인슐린 투여율이다.

정상점 부근 선형화를 통해 상태공간 모델을 구성하면:

A = [[-p₁,   -Gb,    0  ],
     [ 0,   -p₂,    p₃ ],
     [ 0,    0,    -n  ]]

B = [0, 0, 1/Vi]ᵀ
C = [1, 0, 0]

PID 제어기 설계

제어 법칙은 다음과 같다:

u(t) = Kp·e(t) + Ki∫e(τ)dτ + Kd·de(t)/dt

전달함수 형태:

C(s) = (Kd·s² + Kp·s + Ki) / s

폐루 전달함수 T(s) = G(s)C(s)/(1 + G(s)C(s))의 특성방정식이 모든 근을 좌반평면에 갖도록 파라미터를 조정한다. 로스-허위츠(Routh-Hurwitz) 판별법을 적용하면 안정 조건을 명시적으로 도출할 수 있다.

칼만 필터를 활용한 상태 추정

연속혈당측정기(CGM)의 노이즈와 지연을 보상하기 위해 칼만 필터를 적용한다. 상태 x = [G, Ġ]ᵀ를 추정하는 예측-보정 순환:

예측 단계:
  x̂ₖ|ₖ₋₁ = Ad·x̂ₖ₋₁|ₖ₋₁ + Bd·uₖ₋₁
  Pₖ|ₖ₋₁ = Ad·Pₖ₋₁|ₖ₋₁·Adᵀ + Q

보정 단계:
  Kₖ = Pₖ|ₖ₋₁·Cᵀ·(C·Pₖ|ₖ₋₁·Cᵀ + R)⁻¹
  x̂ₖ|ₖ = x̂ₖ|ₖ₋₁ + Kₖ·(yₖ - C·x̂ₖ|ₖ₋₁)
  Pₖ|ₖ = (I - Kₖ·C)·Pₖ|ₖ₋₁

Python 구현 예시

재구성된 PID 제어기

import numpy as np
from typing import Optional, Tuple

class InsulinPID:
    def __init__(self, Kp: float, Ki: float, Kd: float,
                 target: float = 100.0,
                 out_min: float = 0.0,
                 out_max: float = 100.0):
        self.Kp = Kp
        self.Ki = Ki
        self.Kd = Kd
        self.target = target
        self.out_min = out_min
        self.out_max = out_max
        
        self._integral = 0.0
        self._prev_err = None
        self._windup_guard = 50.0  # 적분 와인드업 방지
    
    def compute(self, measured: float, dt: float) -> float:
        err = self.target - measured
        
        # 비례항
        prop = self.Kp * err
        
        # 적분항 (와인드업 제한)
        self._integral += err * dt
        self._integral = np.clip(self._integral,
                                -self._windup_guard,
                                self._windup_guard)
        integ = self.Ki * self._integral
        
        # 미분항
        if self._prev_err is None:
            deriv = 0.0
        else:
            deriv = self.Kd * (err - self._prev_err) / dt
        self._prev_err = err
        
        output = prop + integ + deriv
        return np.clip(output, self.out_min, self.out_max)
    
    def reset(self):
        self._integral = 0.0
        self._prev_err = None

혈당 시뮬레이션 환경

class GlucoseSimulator:
    def __init__(self, p1=0.028, p2=0.025, p3=1.3e-5,
                 Gb=81, n=0.093, Vi=120):
        self.params = {
            'p1': p1, 'p2': p2, 'p3': p3,
            'Gb': Gb, 'n': n, 'Vi': Vi
        }
        self.G = Gb  # 혈당
        self.X = 0.0  # 인슐린 작용
        self.I = 15.0  # 기저 인슐린
    
    def step(self, u: float, dt: float, meal: float = 0.0):
        """한 스텝 진행"""
        p = self.params
        dG = (-p['p1']*(self.G - p['Gb']) - self.X*self.G
              + meal/117.0) * dt
        dX = (-p['p2']*self.X + p['p3']*(self.I - 15.0)) * dt
        dI = (-p['n']*self.I + u/p['Vi']) * dt
        
        self.G = max(self.G + dG, 20.0)  # 최저 혈당 제한
        self.X += dX
        self.I = max(self.I + dI, 0.0)
        
        return self.G

폐루 시뮬레이션 실행

def run_closed_loop(Kp=0.5, Ki=0.01, Kd=2.0,
                   T=300, dt=1.0, G0=150.0):
    controller = InsulinPID(Kp, Ki, Kd, target=100.0)
    plant = GlucoseSimulator()
    plant.G = G0
    
    times = np.arange(0, T, dt)
    glucose = np.zeros(len(times))
    insulin = np.zeros(len(times))
    
    # 식사 프로파일 (60분에 300 mg/min, 30분간)
    meals = np.zeros(len(times))
    meals[60:90] = 300.0
    
    for i, t in enumerate(times):
        # 측정 (노이즈 추가 가능)
        G_meas = plant.G + np.random.normal(0, 5)
        
        # PID 제어
        u = controller.compute(G_meas, dt)
        
        # 식사 방해
        meal = meals[i]
        
        # 플랜트 진행
        plant.step(u, dt, meal)
        
        glucose[i] = plant.G
        insulin[i] = u
    
    return times, glucose, insulin

성능 평가 및 최적화

시뮬레이션 결과를 평가하는 지표들:

def evaluate_control(time, glucose, target=100.0):
    # 정상 오차
    ess = abs(np.mean(glucose[-30:]) - target)
    
    # 목표 범위 내 시간 비율 (80-120 mg/dL)
    in_range = np.sum((glucose >= 80) & (glucose <= 120))
    time_in_range = in_range / len(glucose) * 100
    
    # 저혈당 이벤트 (< 70 mg/dL)
    hypo_events = np.sum(glucose < 70)
    
    # 오버슈트
    overshoot = max(0, (target - np.min(glucose)) / target * 100)
    
    return {
        'steady_error': ess,
        'time_in_range': time_in_range,
        'hypo_events': hypo_events,
        'overshoot': overshoot
    }

연습 문제

기초: 개루/폐루 판별

다음 시스템의 제어 방식을 분석하라:

1. 설정 시간만으로 작동하는 전기 담요
2. 체온 센서 피드백을 받는 수술용 난방 장치
3. 고정 주기로 배액하는 투석기
4. 혈압 측정값으로 모터 속도를 조절하는 심장 보조 장치

심화: 상태공간 설계

다음 약물 대사 방정식을 상태공간으로 변환하고 안정성을 판별하라:

ẍ + 3ẋ + 2x = u

상태변수 x₁ = x, x₂ = ẋ로 설정하면:

A = [[ 0,  1],
     [-2, -3]],  B = [[0], [1]],  C = [[1, 0]]

특성방정식 det(sI - A) = s² + 3s + 2 = (s+1)(s+2) = 0의 근이 모두 음수이므로 시스템은 점근 안정이다.

도전: 파라미터 최적화

주어진 환자 모델에 대해 PID 파라미터를 그리드 서치로 최적화하고, 다음 제약 조건을 만족하는지 검증하라:

• 정상 오차 < 5 mg/dL
• 최저 혈당 > 70 mg/dL
• 목표 범위(80-120) 내 시간 > 80%

def optimize_pid_grid(patient_model, G0=150, T=300):
    best_score = -np.inf
    best_params = None
    
    for Kp in np.linspace(0.1, 2.0, 15):
        for Ki in np.linspace(0.001, 0.05, 10):
            for Kd in np.linspace(0.5, 5.0, 10):
                t, G, u = run_closed_loop(Kp, Ki, Kd, T=T, G0=G0)
                metrics = evaluate_control(t, G)
                
                # 제약 조건 검증
                if (metrics['steady_error'] < 5 and
                    metrics['hypo_events'] == 0 and
                    metrics['time_in_range'] > 80):
                    
                    score = metrics['time_in_range'] - metrics['overshoot']
                    if score > best_score:
                        best_score = score
                        best_params = (Kp, Ki, Kd)
    
    return best_params, best_score

핵심 정리

• 폐루 제어는 피드백을 통해 외란에 강인하고 정밀도가 높아 의료 기기에 필수적이다
• 상태공간 모델은 다변수 의료 시스템의 직관적 표현과 분석을 가능하게 한다
• 리아푸노프 안정성은 비선형 시스템을 포함한 광범위한 안정성 판단 기준을 제공한다
• 칼만 필터는 센서 노이즈와 지연 속에서도 정확한 상태 추정을 실현한다
• 인슐린 펌프 등 의료 폐루 시스템은 안전성과 성능의 균형이 중요하며, 체계적인 시뮬레이션과 검증이 필요하다