1️⃣ 중앙집중식 아키텍처 (Centralized Architecture)

이 방식은 마치 오케스트라의 지휘자처럼 중앙 제어 시스템이 모든 로봇을 통제하는 구조야.

작동 방식:
• 중앙 서버가 모든 로봇의 센서 데이터를 수집해
• 전체 상황을 분석하고 최적의 계획을 수립해
• 각 로봇에게 구체적인 명령을 전달해
• 로봇들은 명령을 받아 실행만 해

장점:
✅ 전역 최적화가 가능해 - 전체 시스템을 한눈에 보니까 가장 효율적인 방법을 찾을 수 있지
✅ 구현이 상대적으로 간단해 - 복잡한 의사결정은 중앙에서만 하면 되니까
✅ 일관성 있는 제어가 가능해

단점:
❌ 중앙 서버가 고장나면 전체 시스템이 마비돼 (단일 실패 지점)
❌ 통신 지연이 발생할 수 있어
❌ 로봇 수가 많아지면 중앙 서버의 부하가 급증해
❌ 확장성(Scalability)이 제한적이야

// 중앙집중식 제어 예시 (Python 스타일 의사코드)
class CentralController:
    def __init__(self):
        self.robots = []
        self.global_map = Map()
    
    def update_global_state(self):
        # 모든 로봇으로부터 상태 정보 수집
        for robot in self.robots:
            sensor_data = robot.get_sensor_data()
            self.global_map.update(sensor_data)
    
    def plan_and_assign_tasks(self):
        # 전역 최적화 알고리즘 실행
        optimal_plan = self.optimize_task_allocation()
        
        # 각 로봇에 명령 전달
        for robot, task in optimal_plan:
            robot.execute_command(task)

2️⃣ 분산식 아키텍처 (Decentralized Architecture)

이건 완전히 반대야! 중앙 제어자 없이 각 로봇이 자율적으로 판단하고 행동하는 구조지. 마치 개미 군집처럼 말이야. 🐜

작동 방식:
• 각 로봇이 독립적으로 센서 데이터를 처리해
• 주변 로봇들과 직접 통신하며 정보를 교환해
• 로컬 정보를 바탕으로 자체적으로 의사결정을 내려
• 전체 시스템의 행동은 개별 로봇들의 상호작용에서 창발(emergence)돼

장점:
✅ 견고성이 뛰어나 - 한 로봇이 고장나도 나머지는 계속 작동해
✅ 확장성이 좋아 - 로봇을 추가하기 쉬워
✅ 통신 부하가 분산돼
✅ 실시간 반응이 빨라

단점:
❌ 전역 최적화가 어려워 - 각자 판단하다 보니 전체적으로는 비효율적일 수 있어
❌ 구현이 복잡해 - 각 로봇이 똑똑해야 하거든
❌ 예측 가능성이 낮아 - 창발적 행동은 때로 예상 밖의 결과를 낳기도 해
❌ 디버깅이 어려워

// 분산식 제어 예시
class AutonomousRobot:
    def __init__(self, robot_id):
        self.id = robot_id
        self.local_map = Map()
        self.neighbors = []
    
    def run(self):
        while True:
            # 센서로 주변 환경 인식
            self.sense_environment()
            
            # 이웃 로봇들과 정보 교환
            self.communicate_with_neighbors()
            
            # 로컬 정보 기반 의사결정
            action = self.decide_action()
            
            # 행동 실행
            self.execute(action)
    
    def decide_action(self):
        # 로컬 센서 데이터와 이웃 정보만으로 판단
        if self.detect_obstacle():
            return self.avoid_obstacle()
        elif self.neighbor_needs_help():
            return self.assist_neighbor()
        else:
            return self.continue_task()

3️⃣ 하이브리드 아키텍처 (Hybrid Architecture)

현실에서는 대부분 이 방식을 써! 중앙집중식과 분산식의 장점을 결합한 거야. 🎭

작동 방식:
• 상위 레벨에서는 중앙 시스템이 전체 계획을 수립해
• 하위 레벨에서는 각 로봇이 자율적으로 실행해
• 계층적 구조로 책임을 분담해
• 상황에 따라 제어 방식을 전환할 수 있어

실제 적용 예시:
재능넷 같은 플랫폼에서 다중 로봇 시스템 개발 프로젝트를 진행한다면, 대부분 하이브리드 방식을 채택할 거야. 왜냐하면 실제 산업 현장에서는 전역 최적화도 필요하고, 실시간 반응성도 중요하거든!

예를 들어 물류 창고 시스템이라면:
• 중앙 시스템: 전체 재고 관리, 작업 우선순위 결정, 경로 최적화
• 개별 로봇: 장애물 회피, 긴급 상황 대응, 세부 경로 조정

// 하이브리드 아키텍처 예시
class HybridSystem:
    def __init__(self):
        self.central_planner = CentralPlanner()
        self.robots = [SmartRobot(i) for i in range(10)]
    
    def run(self):
        # 중앙에서 고수준 계획 수립
        global_plan = self.central_planner.create_plan()
        
        # 각 로봇에 목표 할당
        for robot, goal in zip(self.robots, global_plan):
            robot.set_goal(goal)
            # 로봇은 자율적으로 목표 달성 방법 결정
            robot.start_autonomous_execution()

class SmartRobot:
    def set_goal(self, goal):
        self.goal = goal
    
    def start_autonomous_execution(self):
        while not self.reached_goal():
            # 자율적으로 경로 계획 및 실행
            self.local_planning()
            self.avoid_dynamic_obstacles()
            self.coordinate_with_nearby_robots()

목표: 여러 로봇이 협력해서 창고 내 물품을 효율적으로 운반하고 정리하기

시스템 구성:
• 10~50대의 자율주행 로봇 (AGV: Automated Guided Vehicle)
• 중앙 관리 시스템 (재고 관리, 주문 처리)
• 센서 네트워크 (위치 추적, 장애물 감지)
• 충전 스테이션

핵심 도전과제:

1. 동적 경로 최적화
로봇들이 실시간으로 움직이는 환경에서 서로 부딪히지 않으면서 최단 경로로 이동해야 해. 이를 위해 Multi-Agent Path Finding (MAPF) 알고리즘을 사용할 수 있어.

2. 작업 우선순위 관리
긴급 주문과 일반 주문을 어떻게 처리할까? 배터리가 부족한 로봇은 어떻게 관리할까? 이런 복잡한 제약 조건을 고려한 스케줄링이 필요해.

3. 교착 상태(Deadlock) 방지
좁은 통로에서 로봇들이 서로를 막아서 아무도 움직이지 못하는 상황을 방지해야 해. 이를 위해 예약 시스템이나 우선순위 규칙을 적용해.

// 창고 로봇 시스템 예시
class WarehouseRobotSystem:
    def __init__(self):
        self.robots = []
        self.task_queue = PriorityQueue()
        self.map = WarehouseMap()
        self.path_planner = MAPFPlanner()
    
    def assign_tasks(self):
        while not self.task_queue.empty():
            task = self.task_queue.get()
            
            # 가용 로봇 중 최적 선택
            available_robots = [r for r in self.robots if r.is_idle()]
            if not available_robots:
                self.task_queue.put(task)  # 다시 큐에 넣기
                break
            
            best_robot = self.select_best_robot(task, available_robots)
            
            # 경로 계획 (다른 로봇들 고려)
            path = self.path_planner.plan_path(
                best_robot.position,
                task.location,
                [r.current_path for r in self.robots if r.is_moving()]
            )
            
            best_robot.assign_task(task, path)
    
    def handle_conflicts(self):
        # 충돌 예측 및 해결
        conflicts = self.detect_conflicts()
        
        for conflict in conflicts:
            robot1, robot2 = conflict
            
            # 우선순위 기반 해결
            if robot1.priority > robot2.priority:
                robot2.wait_or_replan()
            else:
                robot1.wait_or_replan()
    
    def optimize_battery_management(self):
        for robot in self.robots:
            if robot.battery_level < 20:
                # 충전소로 보내기
                charging_station = self.find_nearest_charging_station(robot)
                robot.go_to_charge(charging_station)

실험 결과 측정 지표:
• 작업 완료 시간 (Makespan)
• 로봇 활용률 (Utilization Rate)
• 충돌 발생 횟수
• 에너지 효율성
• 시스템 처리량 (Throughput)

목표: 지진이나 화재 같은 재난 현장에서 다중 드론과 지상 로봇이 협력해서 생존자를 찾고 구조하기

시스템 구성:
• 공중 드론 5~10대 (넓은 지역 탐색, 열화상 카메라)
• 지상 로봇 3~5대 (좁은 공간 진입, 물품 운반)
• 이종 로봇 간 통신 시스템
• 원격 제어 센터

핵심 도전과제:

1. 불확실한 환경 매핑
재난 현장은 지도가 없거나 부정확해. 로봇들이 실시간으로 환경을 탐색하고 지도를 만들어야 해. 이를 SLAM (Simultaneous Localization and Mapping)이라고 해.

2. 통신 제약
건물 잔해나 화재로 인해 통신이 불안정해. 로봇들은 통신이 끊겨도 자율적으로 작동하고, 다시 연결되면 정보를 동기화해야 해.

3. 이종 로봇 협업
드론과 지상 로봇은 능력이 다르지. 드론은 빠르게 넓은 지역을 탐색하고, 지상 로봇은 정밀한 작업을 수행해. 이들의 강점을 어떻게 조합할까?

// 재난 구조 시스템 예시
class DisasterResponseSystem:
    def __init__(self):
        self.aerial_drones = []
        self.ground_robots = []
        self.shared_map = OccupancyGrid()
        self.survivor_locations = []
    
    def coordinate_search(self):
        # 1단계: 드론으로 광역 탐색
        search_areas = self.divide_search_area()
        
        for drone, area in zip(self.aerial_drones, search_areas):
            drone.search_area(area)
            
            # 열화상 카메라로 생존자 감지
            detected = drone.detect_heat_signatures()
            
            if detected:
                self.survivor_locations.extend(detected)
                # 지상 로봇에게 알림
                self.notify_ground_robots(detected)
        
        # 2단계: 지상 로봇으로 정밀 확인
        for location in self.survivor_locations:
            nearest_robot = self.find_nearest_ground_robot(location)
            nearest_robot.investigate(location)
    
    def handle_communication_loss(self, robot):
        # 통신 단절 시 자율 모드 전환
        robot.switch_to_autonomous_mode()
        
        # 마지막 알려진 정보로 계속 작업
        robot.continue_with_last_known_plan()
        
        # 주기적으로 재연결 시도
        robot.attempt_reconnection(interval=30)
    
    def merge_maps(self):
        # 각 로봇이 만든 지도를 통합
        for robot in self.aerial_drones + self.ground_robots:
            local_map = robot.get_local_map()
            self.shared_map.merge(local_map)
        
        # 불일치 해결 (같은 위치에 대한 다른 정보)
        self.shared_map.resolve_conflicts()
        
        # 모든 로봇에게 업데이트된 지도 배포
        self.broadcast_updated_map()
    
    def prioritize_rescue_operations(self):
        # 생존자 위치를 위험도와 접근성으로 평가
        priorities = []
        
        for location in self.survivor_locations:
            risk_level = self.assess_risk(location)
            accessibility = self.assess_accessibility(location)
            
            priority_score = risk_level * 0.7 + accessibility * 0.3
            priorities.append((location, priority_score))
        
        # 우선순위 순으로 정렬
        priorities.sort(key=lambda x: x[1], reverse=True)
        
        return priorities

실험 결과 측정 지표:
• 탐색 완료 시간
• 생존자 발견율
• 지도 정확도
• 통신 단절 시 자율 작동 성공률
• 로봇 생존율 (위험한 환경이니까!)

목표: 수십~수백 대의 작은 로봇들이 협력해서 큰 구조물을 건설하기 (개미나 벌처럼!)

시스템 구성:
• 50~200대의 소형 로봇
• 분산 제어 시스템 (중앙 제어 없음)
• 로컬 센서와 통신 모듈
• 건축 블록 또는 재료

핵심 도전과제:

1. 창발적 행동 설계
각 로봇은 간단한 규칙만 따르지만, 전체적으로는 복잡한 구조물이 만들어져야 해. 이런 창발(emergence)을 어떻게 설계할까?

2. 확장성
로봇이 10대든 1000대든 시스템이 작동해야 해. 중앙 제어 없이 어떻게 조정할까?

3. 견고성
일부 로봇이 고장나도 건설이 계속되어야 해. 시스템이 자가 치유(self-healing) 능력을 가져야 해.

// 군집 건설 로봇 예시
class SwarmConstructionRobot:
    def __init__(self, robot_id):
        self.id = robot_id
        self.position = None
        self.carrying_block = False
        self.local_structure_map = {}
    
    def run(self):
        while not self.construction_complete():
            # 간단한 규칙 기반 행동
            
            if not self.carrying_block:
                # 규칙 1: 블록이 없으면 가져오기
                self.go_to_block_source()
                self.pick_up_block()
            else:
                # 규칙 2: 블록을 놓을 위치 찾기
                placement_location = self.find_placement_location()
                
                if placement_location:
                    self.move_to(placement_location)
                    self.place_block()
                else:
                    # 규칙 3: 적절한 위치가 없으면 탐색
                    self.explore()
    
    def find_placement_location(self):
        # 로컬 센서로 주변 구조 파악
        nearby_blocks = self.sense_nearby_blocks()
        
        # 간단한 규칙: 기존 블록 옆에 놓기
        for block in nearby_blocks:
            adjacent_positions = self.get_adjacent_positions(block)
            
            for pos in adjacent_positions:
                if self.is_valid_placement(pos):
                    return pos
        
        return None
    
    def is_valid_placement(self, position):
        # 물리적 제약 확인
        if not self.is_stable(position):
            return False
        
        # 다른 로봇과 충돌 확인
        if self.is_occupied_by_robot(position):
            return False
        
        # 설계 패턴과 일치 확인 (간접적으로)
        if not self.matches_local_pattern(position):
            return False
        
        return True
    
    def matches_local_pattern(self, position):
        # 주변 블록 배치를 보고 패턴 추론
        # 예: 벽을 만들고 있다면 일직선으로 계속
        # 탑을 만들고 있다면 위로 쌓기
        
        nearby_pattern = self.analyze_nearby_structure()
        
        if nearby_pattern == 'wall':
            return self.is_aligned_with_wall(position)
        elif nearby_pattern == 'tower':
            return self.is_above_existing_block(position)
        else:
            return True  # 패턴 불명확하면 허용

# 시뮬레이션 실행
class SwarmSimulation:
    def __init__(self, num_robots=100):
        self.robots = [SwarmConstructionRobot(i) for i in range(num_robots)]
        self.structure = Structure()
    
    def run_simulation(self, max_steps=10000):
        for step in range(max_steps):
            # 모든 로봇 동시 실행
            for robot in self.robots:
                robot.run()
            
            # 구조물 진행 상황 기록
            self.structure.update()
            
            if self.structure.is_complete():
                print(f"Construction complete in {step} steps!")
                break

실험 결과 측정 지표:
• 건설 완료 시간
• 구조물 정확도 (설계와의 일치도)
• 로봇 활용률
• 고장 로봇 비율에 따른 성능 저하
• 확장성 (로봇 수 증가 시 효율성 변화)

목표: 화성이나 달 같은 미지의 행성을 여러 로봇이 협력해서 탐사하고 샘플 수집하기

시스템 구성:
• 이동 로봇 3~5대 (다양한 지형 대응)
• 정찰 드론 2~3대
• 베이스 캠프 (통신 중계, 샘플 보관)
• 지구와의 장거리 통신 (수분~수십분 지연)

핵심 도전과제:

1. 극심한 통신 지연
지구와의 통신에 수분이 걸려. 실시간 제어가 불가능하니 로봇들이 완전히 자율적으로 작동해야 해. 🌌

2. 제한된 에너지
태양광 패널이나 배터리에 의존하는데, 밤이나 모래폭풍 때는 충전이 안 돼. 에너지 효율적인 협업이 필수야.

3. 미지의 환경
지형, 기후, 위험 요소를 전혀 모르는 상태에서 탐사해야 해. 적응적 학습이 중요해.

// 행성 탐사 시스템 예시
class PlanetaryExplorationSystem:
    def __init__(self):
        self.rovers = []
        self.drones = []
        self.base_camp = BaseCamp()
        self.exploration_map = Map()
        self.samples_collected = []
    
    def autonomous_exploration(self):
        # 지구로부터의 고수준 목표만 받음
        mission_objectives = self.receive_mission_objectives()
        
        # 로봇들이 자율적으로 계획 수립
        exploration_plan = self.create_exploration_plan(mission_objectives)
        
        # 분산 실행
        for rover in self.rovers:
            rover.set_exploration_goal(exploration_plan[rover.id])
            rover.start_autonomous_exploration()
        
        for drone in self.drones:
            drone.conduct_aerial_survey()
    
    def coordinate_with_delay(self):
        # 통신 지연을 고려한 조정
        
        # 로컬 의사결정 (즉시)
        for rover in self.rovers:
            if rover.detects_interesting_feature():
                # 다른 로버에게 알림 (로컬 통신, 지연 작음)
                self.notify_nearby_rovers(rover)
        
        # 글로벌 의사결정 (지연 허용)
        if self.significant_discovery():
            # 지구에 보고하고 지시 대기
            self.report_to_earth()
            # 지시를 기다리는 동안 다른 작업 계속
            self.continue_routine_exploration()
    
    def energy_aware_collaboration(self):
        # 에너지 상태 모니터링
        energy_status = {r.id: r.battery_level for r in self.rovers}
        
        # 에너지 부족한 로버는 베이스캠프로
        for rover in self.rovers:
            if rover.battery_level < 30:
                rover.return_to_base()
                continue
            
            # 에너지 충분한 로버는 더 먼 곳 탐사
            if rover.battery_level > 70:
                rover.explore_distant_area()
            else:
                rover.explore_nearby_area()
    
    def adaptive_learning(self):
        # 탐사하면서 환경 학습
        
        for rover in self.rovers:
            # 지형 데이터 수집
            terrain_data = rover.analyze_terrain()
            
            # 이동 모델 업데이트
            rover.update_mobility_model(terrain_data)
            
            # 다른 로버와 학습 내용 공유
            rover.share_learned_model()
        
        # 집단 지식 통합
        self.integrate_collective_knowledge()
    
    def sample_collection_strategy(self):
        # 과학적 가치와 수집 비용을 고려한 전략
        
        potential_samples = self.identify_potential_samples()
        
        # 가치 평가
        for sample in potential_samples:
            scientific_value = self.assess_scientific_value(sample)
            collection_cost = self.estimate_collection_cost(sample)
            
            priority = scientific_value / collection_cost
            sample.priority = priority
        
        # 우선순위 순으로 수집
        sorted_samples = sorted(potential_samples, 
                               key=lambda s: s.priority, 
                               reverse=True)
        
        # 로버에 할당
        for sample in sorted_samples[:10]:  # 상위 10개
            best_rover = self.find_best_rover_for_sample(sample)
            best_rover.collect_sample(sample)

실험 결과 측정 지표:
• 탐사 면적
• 수집된 샘플 수와 다양성
• 에너지 효율성
• 자율 작동 성공률
• 과학적 발견의 가치

1. Gazebo + ROS

가장 널리 사용되는 조합이야! Gazebo는 3D 물리 시뮬레이터고, ROS(Robot Operating System)는 로봇 소프트웨어 프레임워크야.

장점:
✅ 오픈소스이고 무료야
✅ 실제 로봇으로 전환이 쉬워 (같은 코드 사용 가능)
✅ 커뮤니티가 크고 자료가 많아
✅ 다양한 센서와 로봇 모델 지원

시작하기:

# ROS 설치 (Ubuntu 기준)
sudo apt update
sudo apt install ros-noetic-desktop-full

# Gazebo 설치
sudo apt install ros-noetic-gazebo-ros-pkgs

# 다중 로봇 패키지 설치
sudo apt install ros-noetic-turtlebot3-*

# 환경 변수 설정
echo "source /opt/ros/noetic/setup.bash" >> ~/.bashrc
source ~/.bashrc

# 간단한 다중 로봇 시뮬레이션 실행
export TURTLEBOT3_MODEL=burger
roslaunch turtlebot3_gazebo multi_turtlebot3.launch

재능넷에서 ROS 전문가를 찾아 멘토링을 받으면 훨씬 빠르게 배울 수 있어! 특히 초기 설정이나 디버깅에서 많은 도움을 받을 수 있지. 🎓

2. Webots

사용자 친화적인 인터페이스를 가진 로봇 시뮬레이터야. 프로그래밍 언어도 Python, C++, Java 등 다양하게 지원해.

장점:
✅ GUI가 직관적이야
✅ 설치와 설정이 간단해
✅ 교육용으로 좋아
✅ 크로스 플랫폼 (Windows, Mac, Linux)

간단한 예제:

# Python으로 Webots 로봇 제어
from controller import Robot, Motor, DistanceSensor

class MultiRobotController:
    def __init__(self):
        self.robot = Robot()
        self.timestep = int(self.robot.getBasicTimeStep())
        
        # 모터 초기화
        self.left_motor = self.robot.getDevice('left wheel motor')
        self.right_motor = self.robot.getDevice('right wheel motor')
        
        # 센서 초기화
        self.sensors = []
        for i in range(8):
            sensor = self.robot.getDevice(f'ps{i}')
            sensor.enable(self.timestep)
            self.sensors.append(sensor)
    
    def run(self):
        while self.robot.step(self.timestep) != -1:
            # 센서 읽기
            sensor_values = [s.getValue() for s in self.sensors]
            
            # 간단한 장애물 회피
            if max(sensor_values) > 100:
                self.avoid_obstacle()
            else:
                self.move_forward()
    
    def move_forward(self):
        self.left_motor.setVelocity(5.0)
        self.right_motor.setVelocity(5.0)
    
    def avoid_obstacle(self):
        self.left_motor.setVelocity(-2.0)
        self.right_motor.setVelocity(2.0)

# 실행
controller = MultiRobotController()
controller.run()

4. MATLAB Robotics Toolbox

MATLAB을 사용한다면 이게 최고야! 특히 알고리즘 개발과 분석에 강력해.

장점:
✅ 강력한 수학적 도구
✅ 시각화가 뛰어나
✅ 알고리즘 프로토타이핑에 최적
✅ Simulink와 통합

예제:

% MATLAB으로 다중 로봇 시뮬레이션
% 로봇 초기화
numRobots = 5;
robots = cell(1, numRobots);

for i = 1:numRobots
    robots{i} = struct('position', rand(2,1)*10, ...
                       'velocity', zeros(2,1), ...
                       'goal', rand(2,1)*10);
end

% 시뮬레이션 루프
for t = 1:1000
    for i = 1:numRobots
        % 목표로 향하는 힘
        goal_force = robots{i}.goal - robots{i}.position;
        
        % 다른 로봇과의 반발력
        repulsion_force = [0; 0];
        for j = 1:numRobots
            if i ~= j
                diff = robots{i}.position - robots{j}.position;
                dist = norm(diff);
                if dist < 2  % 2미터 이내면 반발
                    repulsion_force = repulsion_force + diff/dist^2;
                end
            end
        end
        
        % 전체 힘 계산
        total_force = 0.1*goal_force + 5*repulsion_force;
        
        % 속도 및 위치 업데이트
        robots{i}.velocity = robots{i}.velocity + 0.01*total_force;
        robots{i}.position = robots{i}.position + 0.01*robots{i}.velocity;
    end
    
    % 시각화
    if mod(t, 10) == 0
        clf;
        hold on;
        for i = 1:numRobots
            plot(robots{i}.position(1), robots{i}.position(2), 'bo', 'MarkerSize', 10);
            plot(robots{i}.goal(1), robots{i}.goal(2), 'r*', 'MarkerSize', 10);
        end
        axis([0 10 0 10]);
        drawnow;
    end
end

최근에는 Multi-Agent Reinforcement Learning (MARL)이 엄청 핫해! 로봇들이 시행착오를 통해 스스로 협업 전략을 학습하는 거야. 🎮

주요 알고리즘:

1. QMIX (Q-Mixing)
각 로봇이 개별 Q-함수를 학습하지만, 이들을 조합해서 전체 팀의 Q-함수를 만들어. 중앙집중식 학습, 분산식 실행이 가능해!

2. MADDPG (Multi-Agent DDPG)
각 에이전트가 다른 에이전트들의 정책을 고려하면서 학습해. 연속적인 행동 공간에 적합해.

3. CommNet
로봇들이 학습된 통신 프로토콜로 정보를 교환하면서 협업해. 통신 자체도 학습의 일부야!

# PyTorch로 간단한 MARL 예시
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

class AgentNetwork(nn.Module):
    def __init__(self, state_dim, action_dim, hidden_dim=128):
        super(AgentNetwork, self).__init__()
        
        self.network = nn.Sequential(
            nn.Linear(state_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, action_dim)
        )
    
    def forward(self, state):
        return self.network(state)

class MARLTrainer:
    def __init__(self, num_agents, state_dim, action_dim):
        self.num_agents = num_agents
        self.agents = [AgentNetwork(state_dim, action_dim) 
                      for _ in range(num_agents)]
        self.optimizers = [optim.Adam(agent.parameters(), lr=0.001) 
                          for agent in self.agents]
        
        self.replay_buffer = []
        self.gamma = 0.99
    
    def select_actions(self, states, epsilon=0.1):
        actions = []
        
        for i, agent in enumerate(self.agents):
            if np.random.random() < epsilon:
                # 탐험: 랜덤 행동
                action = np.random.randint(0, agent.network[-1].out_features)
            else:
                # 활용: 학습된 정책
                with torch.no_grad():
                    state_tensor = torch.FloatTensor(states[i])
                    q_values = agent(state_tensor)
                    action = torch.argmax(q_values).item()
            
            actions.append(action)
        
        return actions
    
    def store_transition(self, states, actions, rewards, next_states, dones):
        self.replay_buffer.append({
            'states': states,
            'actions': actions,
            'rewards': rewards,
            'next_states': next_states,
            'dones': dones
        })
        
        # 버퍼 크기 제한
        if len(self.replay_buffer) > 10000:
            self.replay_buffer.pop(0)
    
    def train(self, batch_size=32):
        if len(self.replay_buffer) < batch_size:
            return
        
        # 미니배치 샘플링
        batch = np.random.choice(self.replay_buffer, batch_size, replace=False)
        
        for agent_id in range(self.num_agents):
            # 각 에이전트 학습
            states = torch.FloatTensor([t['states'][agent_id] for t in batch])
            actions = torch.LongTensor([t['actions'][agent_id] for t in batch])
            rewards = torch.FloatTensor([t['rewards'][agent_id] for t in batch])
            next_states = torch.FloatTensor([t['next_states'][agent_id] for t in batch])
            dones = torch.FloatTensor([t['dones'][agent_id] for t in batch])
            
            # Q-값 계산
            current_q = self.agents[agent_id](states).gather(1, actions.unsqueeze(1))
            
            with torch.no_grad():
                next_q = self.agents[agent_id](next_states).max(1)[0]
                target_q = rewards + self.gamma * next_q * (1 - dones)
            
            # 손실 계산 및 역전파
            loss = nn.MSELoss()(current_q.squeeze(), target_q)
            
            self.optimizers[agent_id].zero_grad()
            loss.backward()
            self.optimizers[agent_id].step()

# 사용 예시
trainer = MARLTrainer(num_agents=5, state_dim=10, action_dim=4)

for episode in range(1000):
    states = env.reset()  # 환경 초기화
    done = False
    episode_reward = 0
    
    while not done:
        # 행동 선택
        actions = trainer.select_actions(states, epsilon=0.1)
        
        # 환경에서 실행
        next_states, rewards, dones = env.step(actions)
        
        # 경험 저장
        trainer.store_transition(states, actions, rewards, next_states, dones)
        
        # 학습
        trainer.train()
        
        states = next_states
        episode_reward += sum(rewards)
        done = all(dones)
    
    print(f"Episode {episode}: Reward = {episode_reward}")

자연에서 영감을 받은 알고리즘들이 정말 효과적이야! 🐜🐝

1. 개미 군집 최적화 (Ant Colony Optimization)
개미들이 페로몬을 남기며 최적 경로를 찾는 방식을 모방해. 경로 계획에 탁월해!

2. 입자 군집 최적화 (Particle Swarm Optimization)
새 떼나 물고기 떼의 움직임을 모방해. 탐색과 최적화에 효과적이야!

3. 꿀벌 알고리즘 (Bee Algorithm)
꿀벌들이 꽃을 찾고 정보를 공유하는 방식을 모방해. 작업 할당에 유용해!

# 개미 군집 최적화 예시
class AntColonyOptimization:
    def __init__(self, num_ants, num_nodes, alpha=1.0, beta=2.0, rho=0.5):
        self.num_ants = num_ants
        self.num_nodes = num_nodes
        self.alpha = alpha  # 페로몬 중요도
        self.beta = beta    # 거리 중요도
        self.rho = rho      # 증발률
        
        # 페로몬 초기화
        self.pheromone = np.ones((num_nodes, num_nodes))
        
        # 거리 행렬 (예시)
        self.distance = np.random.rand(num_nodes, num_nodes) * 100
        np.fill_diagonal(self.distance, 0)
    
    def select_next_node(self, current_node, visited):
        # 방문 가능한 노드
        unvisited = [i for i in range(self.num_nodes) if i not in visited]
        
        if not unvisited:
            return None
        
        # 확률 계산
        probabilities = []
        for node in unvisited:
            pheromone_level = self.pheromone[current_node][node] ** self.alpha
            distance_factor = (1.0 / self.distance[current_node][node]) ** self.beta
            probabilities.append(pheromone_level * distance_factor)
        
        # 정규화
        probabilities = np.array(probabilities)
        probabilities /= probabilities.sum()
        
        # 확률적 선택
        next_node = np.random.choice(unvisited, p=probabilities)
        return next_node
    
    def construct_solution(self):
        # 각 개미가 경로 구성
        all_paths = []
        all_distances = []
        
        for ant in range(self.num_ants):
            path = [0]  # 시작 노드
            visited = {0}
            
            while len(visited) < self.num_nodes:
                current = path[-1]
                next_node = self.select_next_node(current, visited)
                
                if next_node is None:
                    break
                
                path.append(next_node)
                visited.add(next_node)
            
            # 경로 거리 계산
            path_distance = sum(self.distance[path[i]][path[i+1]] 
                              for i in range(len(path)-1))
            
            all_paths.append(path)
            all_distances.append(path_distance)
        
        return all_paths, all_distances
    
    def update_pheromone(self, paths, distances):
        # 증발
        self.pheromone *= (1 - self.rho)
        
        # 페로몬 추가
        for path, distance in zip(paths, distances):
            pheromone_deposit = 1.0 / distance
            
            for i in range(len(path) - 1):
                self.pheromone[path[i]][path[i+1]] += pheromone_deposit
    
    def optimize(self, iterations=100):
        best_path = None
        best_distance = float('inf')
        
        for iteration in range(iterations):
            paths, distances = self.construct_solution()
            
            # 최적 경로 업데이트
            min_distance = min(distances)
            if min_distance < best_distance:
                best_distance = min_distance
                best_path = paths[distances.index(min_distance)]
            
            # 페로몬 업데이트
            self.update_pheromone(paths, distances)
            
            if iteration % 10 == 0:
                print(f"Iteration {iteration}: Best distance = {best_distance:.2f}")
        
        return best_path, best_distance

# 사용 예시
aco = AntColonyOptimization(num_ants=20, num_nodes=10)
best_path, best_distance = aco.optimize(iterations=100)
print(f"Best path: {best_path}")
print(f"Best distance: {best_distance:.2f}")