공정 최적화 AI 개요

1공정 최적화의 정의

공정 최적화(Process Optimization)는 제조 공정의 파라미터를 조정하여 품질, 생산성, 비용 측면에서 최선의 결과를 달성하는 것입니다. 수학적으로는 목적 함수(Objective Function)를 최소화 또는 최대화하는 결정 변수(Decision Variables)의 값을 찾는 문제입니다.

제조 환경에서의 최적화 대상:

• 공정 파라미터: 온도, 압력, 속도, 시간 등
• 생산 스케줄: 작업 순서, 자원 할당, 배치 계획
• 품질 목표: 불량률 최소화, 규격 적합성
• 비용 효율: 에너지, 원자재, 인건비 절감

2전통적 최적화 vs AI 기반 최적화

전통적인 최적화 방법과 AI/ML 기반 접근법의 근본적 차이를 이해하는 것이 중요합니다.

"""
공정 최적화 문제 정의 예시
"""
import numpy as np
from dataclasses import dataclass
from typing import List, Callable, Optional
from enum import Enum

class OptimizationType(Enum):
    MINIMIZE = "minimize"
    MAXIMIZE = "maximize"

@dataclass
class OptimizationVariable:
    """최적화 결정 변수"""
    name: str
    lower_bound: float
    upper_bound: float
    initial_value: Optional[float] = None

    def sample_random(self) -> float:
        return np.random.uniform(self.lower_bound, self.upper_bound)

@dataclass
class Constraint:
    """제약 조건"""
    name: str
    function: Callable
    constraint_type: str  # 'eq' for equality, 'ineq' for inequality

    def evaluate(self, x: np.ndarray) -> float:
        return self.function(x)

    def is_satisfied(self, x: np.ndarray, tolerance: float = 1e-6) -> bool:
        value = self.evaluate(x)
        if self.constraint_type == 'eq':
            return abs(value) <= tolerance
        else:  # inequality: g(x) <= 0
            return value <= tolerance

class ProcessOptimizationProblem:
    """
    제조 공정 최적화 문제 정의
    """
    def __init__(
        self,
        name: str,
        variables: List[OptimizationVariable],
        objective_function: Callable,
        optimization_type: OptimizationType = OptimizationType.MINIMIZE,
        constraints: Optional[List[Constraint]] = None
    ):
        self.name = name
        self.variables = variables
        self.objective_function = objective_function
        self.optimization_type = optimization_type
        self.constraints = constraints or []

        # 변수 경계 설정
        self.bounds = np.array([
            [v.lower_bound, v.upper_bound] for v in variables
        ])

    @property
    def n_variables(self) -> int:
        return len(self.variables)

    def evaluate(self, x: np.ndarray) -> float:
        """목적 함수 평가"""
        return self.objective_function(x)

    def check_constraints(self, x: np.ndarray) -> bool:
        """모든 제약 조건 만족 여부 확인"""
        return all(c.is_satisfied(x) for c in self.constraints)

    def random_initial_point(self) -> np.ndarray:
        """랜덤 초기점 생성"""
        return np.array([v.sample_random() for v in self.variables])


# 예시: 사출성형 공정 최적화 문제
def injection_molding_quality(params: np.ndarray) -> float:
    """
    사출성형 품질 목적 함수
    params: [온도, 압력, 사이클타임, 냉각시간]
    """
    temp, pressure, cycle_time, cooling_time = params

    # 품질 점수 계산 (낮을수록 좋음 - 불량률)
    # 실제로는 이 함수가 ML 모델이 됨
    defect_rate = (
        0.01 * (temp - 220)**2 +  # 최적 온도 220도
        0.005 * (pressure - 80)**2 +  # 최적 압력 80 MPa
        0.02 * max(0, 15 - cycle_time) +  # 최소 사이클타임 15초
        0.03 * max(0, 10 - cooling_time)  # 최소 냉각시간 10초
    )
    return defect_rate

# 문제 정의
injection_problem = ProcessOptimizationProblem(
    name="Injection Molding Optimization",
    variables=[
        OptimizationVariable("temperature", 180, 260, 220),
        OptimizationVariable("pressure", 50, 120, 80),
        OptimizationVariable("cycle_time", 10, 30, 20),
        OptimizationVariable("cooling_time", 5, 20, 12),
    ],
    objective_function=injection_molding_quality,
    optimization_type=OptimizationType.MINIMIZE,
    constraints=[
        Constraint(
            "min_cycle",
            lambda x: 15 - x[2],  # cycle_time >= 15
            "ineq"
        ),
        Constraint(
            "cooling_ratio",
            lambda x: x[3] - 0.6 * x[2],  # cooling <= 60% of cycle
            "ineq"
        )
    ]
)

print(f"문제: {injection_problem.name}")
print(f"변수 개수: {injection_problem.n_variables}")
print(f"변수 경계:\n{injection_problem.bounds}")

3AI 기반 최적화 패러다임

AI 기반 공정 최적화는 크게 세 가지 패러다임으로 분류됩니다.

• 서로게이트 모델 기반: ML 모델로 비용이 큰 시뮬레이션/실험을 대체하고, 이 모델 위에서 최적화 수행
• 강화학습 기반: 에이전트가 공정과 상호작용하며 최적 제어 정책 학습
• 진화 알고리즘 기반: 유전 알고리즘, 입자 군집 최적화 등 메타휴리스틱 적용

"""
AI 기반 최적화 프레임워크
"""
from abc import ABC, abstractmethod
from typing import Tuple, List, Dict
import numpy as np

class BaseOptimizer(ABC):
    """최적화 알고리즘 기본 클래스"""

    def __init__(self, problem: ProcessOptimizationProblem):
        self.problem = problem
        self.history: List[Dict] = []
        self.best_solution: Optional[np.ndarray] = None
        self.best_value: float = float('inf')

    @abstractmethod
    def optimize(self, n_iterations: int) -> Tuple[np.ndarray, float]:
        """최적화 수행"""
        pass

    def _update_best(self, x: np.ndarray, value: float):
        """최선 해 업데이트"""
        if self.problem.optimization_type == OptimizationType.MINIMIZE:
            if value < self.best_value:
                self.best_solution = x.copy()
                self.best_value = value
        else:
            if value > self.best_value:
                self.best_solution = x.copy()
                self.best_value = value

    def _record_iteration(self, iteration: int, x: np.ndarray, value: float):
        """이터레이션 기록"""
        self.history.append({
            'iteration': iteration,
            'x': x.copy(),
            'value': value,
            'best_value': self.best_value
        })


class GridSearchOptimizer(BaseOptimizer):
    """
    그리드 탐색 최적화 (베이스라인)
    """
    def __init__(self, problem: ProcessOptimizationProblem, n_points_per_dim: int = 10):
        super().__init__(problem)
        self.n_points_per_dim = n_points_per_dim

    def optimize(self, n_iterations: int = None) -> Tuple[np.ndarray, float]:
        # 각 차원별 그리드 포인트 생성
        grids = []
        for v in self.problem.variables:
            grids.append(np.linspace(v.lower_bound, v.upper_bound, self.n_points_per_dim))

        # 모든 조합 탐색
        from itertools import product
        iteration = 0
        for point in product(*grids):
            x = np.array(point)

            # 제약 조건 확인
            if not self.problem.check_constraints(x):
                continue

            value = self.problem.evaluate(x)
            self._update_best(x, value)
            self._record_iteration(iteration, x, value)
            iteration += 1

        return self.best_solution, self.best_value


class RandomSearchOptimizer(BaseOptimizer):
    """
    랜덤 탐색 최적화
    """
    def optimize(self, n_iterations: int = 100) -> Tuple[np.ndarray, float]:
        for i in range(n_iterations):
            # 랜덤 포인트 생성
            x = self.problem.random_initial_point()

            # 제약 조건 만족할 때까지 재샘플링
            max_trials = 100
            for _ in range(max_trials):
                if self.problem.check_constraints(x):
                    break
                x = self.problem.random_initial_point()

            value = self.problem.evaluate(x)
            self._update_best(x, value)
            self._record_iteration(i, x, value)

        return self.best_solution, self.best_value


# 최적화 실행 및 비교
print("=" * 50)
print("Grid Search vs Random Search 비교")
print("=" * 50)

# Grid Search
grid_optimizer = GridSearchOptimizer(injection_problem, n_points_per_dim=5)
grid_best_x, grid_best_val = grid_optimizer.optimize()
print(f"\nGrid Search 결과:")
print(f"  최적 파라미터: {grid_best_x}")
print(f"  최적 품질 점수: {grid_best_val:.6f}")
print(f"  평가 횟수: {len(grid_optimizer.history)}")

# Random Search
random_optimizer = RandomSearchOptimizer(injection_problem)
random_best_x, random_best_val = random_optimizer.optimize(n_iterations=100)
print(f"\nRandom Search 결과:")
print(f"  최적 파라미터: {random_best_x}")
print(f"  최적 품질 점수: {random_best_val:.6f}")
print(f"  평가 횟수: {len(random_optimizer.history)}")

4산업별 최적화 적용 사례

AI 기반 공정 최적화는 다양한 산업에서 활용되고 있습니다.