Auto commit at 22-2025-08 19:14:51

lily_llm_api/app_v2.py

@@ -20,6 +20,12 @@ import io
 import os
 import json
 from pathlib import Path
+import warnings
+
+# 🔄 RoPE 경고 숨기기 (Kanana 모델 내부 구현 관련)
+warnings.filterwarnings("ignore", message="The attention layers in this model are transitioning")
+warnings.filterwarnings("ignore", message="rotary_pos_emb will be removed")
+warnings.filterwarnings("ignore", message="position_embeddings will be mandatory")
 
 # logging 설정을 먼저 구성
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -854,11 +860,25 @@ def generate_sync(prompt: str, image_data_list: Optional[List[bytes]], max_lengt
                     print(f"🔍 [DEBUG] 결합된 이미지 텐서 shape: {pixel_values.shape}")
                     print(f"🔍 [DEBUG] 이미지 텐서 dtype: {pixel_values.dtype}")
                     
+                    # 🔄 모델과 동일한 dtype으로 변환 (성능 최적화)
+                    if hasattr(model, 'dtype'):
+                        target_dtype = model.dtype
+                        if pixel_values.dtype != target_dtype:
+                            print(f"🔍 [DEBUG] 이미지 텐서 dtype 변환: {pixel_values.dtype} -> {target_dtype}")
+                            pixel_values = pixel_values.to(dtype=target_dtype)
+                    else:
+                        # 🔄 모델 dtype을 알 수 없는 경우 bfloat16 사용 (Kanana 모델 기본값)
+                        target_dtype = torch.bfloat16
+                        if pixel_values.dtype != target_dtype:
+                            print(f"🔍 [DEBUG] 이미지 텐서 dtype 변환: {pixel_values.dtype} -> {target_dtype}")
+                            pixel_values = pixel_values.to(dtype=target_dtype)
+                    
                     if pixel_values.device != model.device:
                         print(f"🔍 [DEBUG] 이미지 텐서를 모델 디바이스로 이동: {pixel_values.device} -> {model.device}")
                         pixel_values = pixel_values.to(model.device)
                     
                     print(f"🔍 [DEBUG] 최종 이미지 텐서 디바이스: {pixel_values.device}")
+                    print(f"🔍 [DEBUG] 최종 이미지 텐서 dtype: {pixel_values.dtype}")
                     print(f"🔍 [DEBUG] 모델 생성 시작 - 멀티모달")
                     
                     # LoRA 어댑터가 적용된 모델인지 확인
@@ -869,18 +889,31 @@ def generate_sync(prompt: str, image_data_list: Optional[List[bytes]], max_lengt
                         if lora_model:
                             print(f"🔍 [DEBUG] LoRA 모델로 멀티모달 생성 실행")
                             # 🔄 image_metas 파라미터 추가 (공식 방식)
-                            # 🔄 메타데이터를 텐서로 변환 (모델 요구사항)
+                            # 🔄 메타데이터를 공식 구조로 변환 (모델 요구사항)
                             import torch
                             processed_image_metas = {}
-                            for key, value in combined_image_metas.items():
-                                if isinstance(value, list):
-                                    if key == 'vision_grid_thw':
-                                        # 🔄 vision_grid_thw를 텐서로 변환
-                                        processed_image_metas[key] = torch.tensor(value, dtype=torch.long)
-                                        print(f"🔍 [DEBUG] {key} 텐서 변환: {value} -> {processed_image_metas[key].shape}")
+                            
+                            # 🔄 공식 방식: vision_grid_thw를 텐서로 변환
+                            if 'vision_grid_thw' in combined_image_metas:
+                                vision_grid = combined_image_metas['vision_grid_thw']
+                                if isinstance(vision_grid, list):
+                                    # 🔄 Kanana 모델 요구사항: (T, H, W) 형태의 3차원 텐서
+                                    if len(vision_grid) == 1 and len(vision_grid[0]) == 3:
+                                        # [(1, 34, 52)] -> (1, 34, 52) 텐서로 변환
+                                        t, h, w = vision_grid[0]
+                                        # 🔄 3차원 텐서로 변환: (1, H, W) 형태
+                                        processed_image_metas['vision_grid_thw'] = torch.tensor([[t, h, w]], dtype=torch.long)
+                                        print(f"🔍 [DEBUG] vision_grid_thw 텐서 변환: {vision_grid} -> {processed_image_metas['vision_grid_thw'].shape}")
                                     else:
-                                        processed_image_metas[key] = value
+                                        # 🔄 다른 형태의 경우 원본 유지
+                                        processed_image_metas['vision_grid_thw'] = torch.tensor(vision_grid, dtype=torch.long)
+                                        print(f"🔍 [DEBUG] vision_grid_thw 텐서 변환 (기��): {vision_grid} -> {processed_image_metas['vision_grid_thw'].shape}")
                                 else:
+                                    processed_image_metas['vision_grid_thw'] = vision_grid
+                            
+                            # 🔄 다른 메타데이터는 그대로 유지
+                            for key, value in combined_image_metas.items():
+                                if key != 'vision_grid_thw':
                                     processed_image_metas[key] = value
                             
                             generate_kwargs = {
@@ -892,21 +925,43 @@ def generate_sync(prompt: str, image_data_list: Optional[List[bytes]], max_lengt
                             }
                             print(f"🔍 [DEBUG] LoRA 모델 생성 파라미터: {list(generate_kwargs.keys())}")
                             print(f"🔍 [DEBUG] 처리된 image_metas: {list(processed_image_metas.keys())}")
+                            print(f"🔍 [DEBUG] 모델 생성 시작... (타임아웃 없음)")
+                            
+                            # 🔄 생성 전 최종 검증
+                            print(f"🔍 [DEBUG] 최종 파라미터 검증:")
+                            print(f"  - input_ids: {input_ids.shape}, dtype: {input_ids.dtype}")
+                            print(f"  - attention_mask: {attention_mask.shape}, dtype: {attention_mask.dtype}")
+                            print(f"  - pixel_values: {pixel_values.shape}, dtype: {pixel_values.dtype}")
+                            print(f"  - vision_grid_thw: {processed_image_metas.get('vision_grid_thw', 'None')}")
+                            
                             generated_ids = lora_model.generate(**generate_kwargs)
                         else:
                             print(f"⚠️ [DEBUG] LoRA 모델을 가져올 수 없음, 기본 모델 사용")
                             # 🔄 image_metas 파라미터 추가 (공식 방식)
-                            # 🔄 메타데이터를 텐서로 변환 (모델 요구사항)
+                            # 🔄 메타데이터를 공식 구조로 변환 (모델 요구사항)
                             processed_image_metas = {}
-                            for key, value in combined_image_metas.items():
-                                if isinstance(value, list):
-                                    if key == 'vision_grid_thw':
-                                        # 🔄 vision_grid_thw를 텐서로 변환
-                                        processed_image_metas[key] = torch.tensor(value, dtype=torch.long)
-                                        print(f"🔍 [DEBUG] {key} 텐서 변환: {value} -> {processed_image_metas[key].shape}")
+                            
+                            # 🔄 공식 방식: vision_grid_thw를 텐서로 변환
+                            if 'vision_grid_thw' in combined_image_metas:
+                                vision_grid = combined_image_metas['vision_grid_thw']
+                                if isinstance(vision_grid, list):
+                                    # 🔄 Kanana 모델 요구사항: (T, H, W) 형태의 3차원 텐서
+                                    if len(vision_grid) == 1 and len(vision_grid[0]) == 3:
+                                        # [(1, 34, 52)] -> (1, 34, 52) 텐서로 변환
+                                        t, h, w = vision_grid[0]
+                                        # 🔄 3차원 텐서로 변환: (1, H, W) 형태
+                                        processed_image_metas['vision_grid_thw'] = torch.tensor([[t, h, w]], dtype=torch.long)
+                                        print(f"🔍 [DEBUG] vision_grid_thw 텐서 변환: {vision_grid} -> {processed_image_metas['vision_grid_thw'].shape}")
                                     else:
-                                        processed_image_metas[key] = value
+                                        # 🔄 다른 형태의 경우 원본 유지
+                                        processed_image_metas['vision_grid_thw'] = torch.tensor(vision_grid, dtype=torch.long)
+                                        print(f"🔍 [DEBUG] vision_grid_thw 텐서 변환 (기본): {vision_grid} -> {processed_image_metas['vision_grid_thw'].shape}")
                                 else:
+                                    processed_image_metas['vision_grid_thw'] = vision_grid
+                            
+                            # 🔄 다른 메타데이터는 그대로 유지
+                            for key, value in combined_image_metas.items():
+                                if key != 'vision_grid_thw':
                                     processed_image_metas[key] = value
                             
                             generate_kwargs = {
@@ -922,17 +977,30 @@ def generate_sync(prompt: str, image_data_list: Optional[List[bytes]], max_lengt
                     else:
                         print(f"🔍 [DEBUG] LoRA 어댑터 없음 (멀티모달), 기본 ���델 사용")
                         # 🔄 image_metas 파라미터 추가 (공식 방식)
-                        # 🔄 메타데이터를 텐서로 변환 (모델 요구사항)
+                        # 🔄 메타데이터를 공식 구조로 변환 (모델 요구사항)
                         processed_image_metas = {}
-                        for key, value in combined_image_metas.items():
-                            if isinstance(value, list):
-                                if key == 'vision_grid_thw':
-                                    # 🔄 vision_grid_thw를 텐서로 변환
-                                    processed_image_metas[key] = torch.tensor(value, dtype=torch.long)
-                                    print(f"🔍 [DEBUG] {key} 텐서 변환: {value} -> {processed_image_metas[key].shape}")
+                        
+                        # 🔄 공식 방식: vision_grid_thw를 텐서로 변환
+                        if 'vision_grid_thw' in combined_image_metas:
+                            vision_grid = combined_image_metas['vision_grid_thw']
+                            if isinstance(vision_grid, list):
+                                # 🔄 Kanana 모델 요구사항: (T, H, W) 형태의 3차원 텐서
+                                if len(vision_grid) == 1 and len(vision_grid[0]) == 3:
+                                    # [(1, 34, 52)] -> (1, 34, 52) 텐서로 변환
+                                    t, h, w = vision_grid[0]
+                                    # 🔄 3차원 텐서로 변환: (1, H, W) 형태
+                                    processed_image_metas['vision_grid_thw'] = torch.tensor([[t, h, w]], dtype=torch.long)
+                                    print(f"🔍 [DEBUG] vision_grid_thw 텐서 변환: {vision_grid} -> {processed_image_metas['vision_grid_thw'].shape}")
                                 else:
-                                    processed_image_metas[key] = value
+                                    # 🔄 다른 형태의 경우 원본 유지
+                                    processed_image_metas['vision_grid_thw'] = torch.tensor(vision_grid, dtype=torch.long)
+                                    print(f"🔍 [DEBUG] vision_grid_thw 텐서 변환 (기본): {vision_grid} -> {processed_image_metas['vision_grid_thw'].shape}")
                             else:
+                                processed_image_metas['vision_grid_thw'] = vision_grid
+                        
+                        # 🔄 다른 메타데이터는 그대로 유지
+                        for key, value in combined_image_metas.items():
+                            if key != 'vision_grid_thw':
                                 processed_image_metas[key] = value
                         
                         generate_kwargs = {

lily_llm_core/lora_manager.py

@@ -285,11 +285,27 @@ class LoRAManager:
                     if base_model_path:
                         self.load_base_model(base_model_path)
             
-            # LoRA 어댑터 로드
+            # 🔄 모델 타입에 따른 dtype 결정
+            if hasattr(self.base_model, 'config') and hasattr(self.base_model.config, 'model_type'):
+                model_type = self.base_model.config.model_type
+                if model_type in ['kanana-1.5-v', 'vision2seq']:
+                    # 🔄 Kanana 모델: bfloat16 사용
+                    selected_dtype = torch.bfloat16
+                    logger.info(f"🔍 [DEBUG] Kanana 모델 감지: {model_type} -> bfloat16 사용")
+                else:
+                    # 🔄 기타 모델: 기존 로직 사용
+                    selected_dtype = torch.float16 if self.device == "cuda" else torch.float32
+                    logger.info(f"🔍 [DEBUG] 일반 모델 감지: {model_type} -> {selected_dtype} 사용")
+            else:
+                # 🔄 모델 타입을 알 수 없는 경우: 기존 로직 사용
+                selected_dtype = torch.float16 if self.device == "cuda" else torch.float32
+                logger.info(f"🔍 [DEBUG] 모델 타입 미확인 -> {selected_dtype} 사용")
+            
+            # LoRA 어댑터 로드 (모델별 최적 dtype 사용)
             self.lora_model = PeftModel.from_pretrained(
                 self.base_model,
                 adapter_path,
-                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+                torch_dtype=selected_dtype
             )
             
             # 디바이스로 이동

lily_llm_core/lora_manager_250822_1812.py

@@ -0,0 +1,589 @@
+#!/usr/bin/env python3
+"""
+LoRA/QLoRA 관리자 (LoRA Manager)
+LoRA 어댑터를 로드하고 관리하는 시스템
+"""
+
+import logging
+import os
+import json
+import torch
+from typing import Dict, Any, Optional, List, Union
+from pathlib import Path
+import warnings
+import time
+
+# logger를 먼저 정의
+logger = logging.getLogger(__name__)
+
+# PEFT 관련 import (설치되지 않은 경우 경고)
+try:
+    logger.info("🔍 PEFT 라이브러리 import 시도 중...")
+    from peft import (
+        LoraConfig, 
+        get_peft_model, 
+        PeftModel, 
+        TaskType,
+        prepare_model_for_kbit_training
+    )
+    from peft.utils import get_peft_model_state_dict
+    PEFT_AVAILABLE = True
+    logger.info("✅ PEFT 라이브러리 import 성공")
+except ImportError as e:
+    PEFT_AVAILABLE = False
+    logger.error(f"❌ PEFT 라이브러리 import 실패: {e}")
+    logger.error(f"❌ Python 경로: {os.environ.get('PYTHONPATH', 'Not set')}")
+    logger.error(f"❌ 현재 작업 디렉토리: {os.getcwd()}")
+    warnings.warn(f"PEFT 라이브러리가 설치되지 않았습니다. LoRA 기능을 사용할 수 없습니다. 오류: {e}")
+
+# Transformers 관련 import
+try:
+    logger.info("🔍 Transformers 라이브러리 import 시도 중...")
+    from transformers import (
+        AutoModelForCausalLM,
+        AutoTokenizer,
+        BitsAndBytesConfig,
+        TrainingArguments,
+        Trainer,
+        DataCollatorForLanguageModeling
+    )
+    TRANSFORMERS_AVAILABLE = True
+    logger.info("✅ Transformers 라이브러리 import 성공")
+except ImportError as e:
+    TRANSFORMERS_AVAILABLE = False
+    logger.error(f"❌ Transformers 라이브러리 import 실패: {e}")
+    warnings.warn(f"Transformers 라이브러리가 설치되지 않았습니다. 오류: {e}")
+
+class LoRAManager:
+    """LoRA/QLoRA 모델 관리 클래스"""
+    
+    def __init__(self, base_model_path: str = None, device: str = "auto"):
+        """
+        Args:
+            base_model_path: 기본 모델 경로
+            device: 사용할 디바이스 ('auto', 'cpu', 'cuda', 'mps')
+        """
+        logger.info(f"🔧 LoRA 관리자 초기화 시작: PEFT_AVAILABLE={PEFT_AVAILABLE}, TRANSFORMERS_AVAILABLE={TRANSFORMERS_AVAILABLE}")
+        
+        if not PEFT_AVAILABLE:
+            logger.error("❌ PEFT 라이브러리를 사용할 수 없습니다.")
+            logger.error("❌ pip install peft를 실행했는지 확인하세요.")
+            logger.error("❌ 가상환경이 활성화되어 있는지 확인하세요.")
+            raise ImportError("PEFT 라이브러리가 필요합니다. pip install peft를 실행하세요.")
+        
+        if not TRANSFORMERS_AVAILABLE:
+            logger.error("❌ Transformers 라이브러리를 사용할 수 없습니다.")
+            logger.error("❌ pip install transformers를 실행했는지 확인하세요.")
+            raise ImportError("Transformers 라이브러리가 필요합니다. pip install transformers를 실행하세요.")
+        
+        self.base_model_path = base_model_path
+        self.device = self._get_device(device)
+        
+        # 모델 및 토크나이저
+        self.base_model = None
+        self.tokenizer = None
+        self.lora_model = None
+        
+        # LoRA 설정
+        self.lora_config = None
+        self.current_adapter_name = None
+        
+        # 어댑터 저장 경로
+        self.adapters_dir = Path("lora_adapters")
+        self.adapters_dir.mkdir(exist_ok=True)
+        
+        # 로드된 어댑터 목록
+        self.loaded_adapters = {}
+        
+        logger.info(f"🔧 LoRA 관리자 초기화: device={self.device}")
+    
+    def get_model(self):
+        """현재 LoRA 모델 반환"""
+        if self.lora_model is not None:
+            return self.lora_model
+        elif self.base_model is not None:
+            return self.base_model
+        else:
+            logger.warning("⚠️ 로드된 모델이 없습니다.")
+            return None
+    
+    def _get_device(self, device: str) -> str:
+        """사용 가능한 디바이스 확인"""
+        if device == "auto":
+            if torch.cuda.is_available():
+                return "cuda"
+            elif torch.backends.mps.is_available():
+                return "mps"
+            else:
+                return "cpu"
+        return device
+    
+    def load_base_model(self, model_path: str = None, model_type: str = "causal_lm") -> bool:
+        """기본 모델 로드"""
+        try:
+            model_path = model_path or self.base_model_path
+            if not model_path:
+                raise ValueError("모델 경로가 지정되지 않았습니다.")
+            
+            logger.info(f"📥 기본 모델 로딩 시작: {model_path}")
+            
+            # 경로 정규화 및 존재 확인
+            model_path = Path(model_path).resolve()
+            if not model_path.exists():
+                raise FileNotFoundError(f"모델 경���가 존재하지 않습니다: {model_path}")
+            
+            logger.info(f"🔍 모델 경로 확인: {model_path}")
+            logger.info(f"🔍 경로 존재: {model_path.exists()}")
+            logger.info(f"🔍 절대 경로: {model_path.absolute()}")
+            
+            # 토크나이저 로드
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                str(model_path),
+                trust_remote_code=True,
+                local_files_only=True
+            )
+            
+            # 패딩 토큰 설정
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+            
+            # 모델 로드
+            if model_type == "causal_lm":
+                self.base_model = AutoModelForCausalLM.from_pretrained(
+                    str(model_path),
+                    trust_remote_code=True,
+                    local_files_only=True,
+                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                    device_map="auto" if self.device == "cuda" else None
+                )
+            elif model_type == "vision2seq":
+                # 🔄 Vision2Seq 모델 지원 추가 (kanana 등)
+                from transformers import AutoModelForVision2Seq
+                self.base_model = AutoModelForVision2Seq.from_pretrained(
+                    str(model_path),
+                    trust_remote_code=True,
+                    local_files_only=True,
+                    torch_dtype=torch.bfloat16 if self.device == "cuda" else torch.bfloat16,
+                    device_map="auto" if self.device == "cuda" else None
+                )
+            else:
+                raise ValueError(f"지원하지 않는 모델 타입: {model_type}")
+            
+            # 디바이스로 이동
+            if self.device != "cuda":  # cuda는 device_map="auto" 사용
+                self.base_model = self.base_model.to(self.device)
+            
+            self.base_model_path = model_path
+            logger.info(f"✅ 기본 모델 로딩 완료: {model_path}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ 기본 모델 로딩 실패: {e}")
+            return False
+    
+    def create_lora_config(self, 
+                          r: int = 16,
+                          lora_alpha: int = 32,
+                          target_modules: List[str] = None,
+                          lora_dropout: float = 0.1,
+                          bias: str = "none",
+                          task_type: str = "CAUSAL_LM") -> LoraConfig:
+        """LoRA 설정 생성"""
+        if target_modules is None:
+            # 일반적인 모델 아키텍처에 대한 기본값
+            target_modules = ["q_proj", "v_proj", "k_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+        
+        # TaskType 변환 (안전한 방식)
+        logger.info(f"🔍 [DEBUG] 입력된 task_type: {task_type}")
+        
+        try:
+            # 직접 TaskType 사용 (문자열 변환 제거)
+            if task_type == "CAUSAL_LM":
+                task_type_enum = TaskType.CAUSAL_LM
+            elif task_type == "VISION_2_SEQ":
+                # 🔄 Vision2Seq 모델 지원 추가
+                task_type_enum = TaskType.SEQ_2_SEQ_LM  # Vision2Seq는 SEQ_2_SEQ_LM과 유사
+            elif task_type == "SEQ_2_SEQ_LM":
+                task_type_enum = TaskType.SEQ_2_SEQ_LM
+            elif task_type == "SEQUENCE_CLASSIFICATION":
+                task_type_enum = TaskType.SEQUENCE_CLASSIFICATION
+            elif task_type == "TOKEN_CLASSIFICATION":
+                task_type_enum = TaskType.TOKEN_CLASSIFICATION
+            elif task_type == "QUESTION_ANSWERING":
+                task_type_enum = TaskType.QUESTION_ANSWERING
+            else:
+                # 기본값으로 CAUSAL_LM 사용
+                task_type_enum = TaskType.CAUSAL_LM
+                logger.warning(f"⚠️ 알 수 없는 task_type: {task_type}, 기본값 CAUSAL_LM 사용")
+        except Exception as e:
+            logger.error(f"❌ TaskType 변환 실패: {e}, 기본값 CAUSAL_LM 사용")
+            task_type_enum = TaskType.CAUSAL_LM
+        
+        logger.info(f"🔍 [DEBUG] 최종 선택된 TaskType: {task_type_enum}")
+        
+        self.lora_config = LoraConfig(
+            r=r,
+            lora_alpha=lora_alpha,
+            target_modules=target_modules,
+            lora_dropout=lora_dropout,
+            bias=bias,
+            task_type=task_type_enum
+        )
+        
+        logger.info(f"🔧 LoRA 설정 생성: r={r}, alpha={lora_alpha}, target_modules={target_modules}")
+        return self.lora_config
+    
+    def apply_lora_to_model(self, adapter_name: str = "default") -> bool:
+        """LoRA를 기본 모델에 적용"""
+        try:
+            if self.base_model is None:
+                raise ValueError("기본 모델이 로드되지 않았습니다.")
+            
+            if self.lora_config is None:
+                raise ValueError("LoRA 설정이 생성되지 않았습니다.")
+            
+            logger.info(f"🔗 LoRA 어댑터 적용 시작: {adapter_name}")
+            
+            # LoRA 모델 생성
+            self.lora_model = get_peft_model(self.base_model, self.lora_config)
+            
+            # 어댑터 이름 설정
+            self.current_adapter_name = adapter_name
+            
+            # 훈련 모드로 설정
+            self.lora_model.train()
+            
+            # 모델 정보 출력
+            self.lora_model.print_trainable_parameters()
+            
+            logger.info(f"✅ LoRA 어댑터 적용 완료: {adapter_name}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ LoRA 어댑터 적용 실패: {e}")
+            return False
+    
+    def load_lora_adapter(self, adapter_path: str, adapter_name: str = None) -> bool:
+        """저장된 LoRA 어댑터 로드"""
+        try:
+            if not os.path.exists(adapter_path):
+                raise FileNotFoundError(f"어댑터 경로를 찾을 수 없습니다: {adapter_path}")
+            
+            if adapter_name is None:
+                adapter_name = Path(adapter_path).stem
+            
+            logger.info(f"📥 LoRA 어댑터 로딩 시작: {adapter_path}")
+            
+            # 기본 모델이 로드되지 않은 경우 로드
+            if self.base_model is None:
+                # 어댑터 설정 파일에서 기본 모델 경로 확인
+                config_path = os.path.join(adapter_path, "adapter_config.json")
+                if os.path.exists(config_path):
+                    with open(config_path, 'r') as f:
+                        config = json.load(f)
+                    base_model_path = config.get("base_model_name_or_path")
+                    if base_model_path:
+                        self.load_base_model(base_model_path)
+            
+            # 🔄 모델 타입에 따른 dtype 결정
+            if hasattr(self.base_model, 'config') and hasattr(self.base_model.config, 'model_type'):
+                model_type = self.base_model.config.model_type
+                if model_type in ['kanana-1.5-v', 'vision2seq']:
+                    # 🔄 Kanana 모델: bfloat16 사용
+                    selected_dtype = torch.bfloat16
+                    logger.info(f"🔍 [DEBUG] Kanana 모델 감지: {model_type} -> bfloat16 사용")
+                else:
+                    # 🔄 기타 모델: 기존 로직 사용
+                    selected_dtype = torch.float16 if self.device == "cuda" else torch.float32
+                    logger.info(f"🔍 [DEBUG] 일반 모델 감지: {model_type} -> {selected_dtype} 사용")
+            else:
+                # 🔄 모델 타입을 알 수 없는 경우: 기존 로직 사용
+                selected_dtype = torch.float16 if self.device == "cuda" else torch.float32
+                logger.info(f"🔍 [DEBUG] 모델 타입 미확인 -> {selected_dtype} 사용")
+            
+            # LoRA 어댑터 로드 (모델별 최적 dtype 사용)
+            self.lora_model = PeftModel.from_pretrained(
+                self.base_model,
+                adapter_path,
+                torch_dtype=selected_dtype
+            )
+            
+            # 디바이스로 이동
+            if self.device != "cuda":
+                self.lora_model = self.lora_model.to(self.device)
+            
+            self.current_adapter_name = adapter_name
+            self.loaded_adapters[adapter_name] = adapter_path
+            
+            logger.info(f"✅ LoRA 어댑터 로딩 완료: {adapter_name}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ LoRA 어댑터 로딩 실패: {e}")
+            return False
+    
+    def save_lora_adapter(self, adapter_name: str = None, output_dir: str = None) -> bool:
+        """LoRA 어댑터 저장"""
+        try:
+            if self.lora_model is None:
+                raise ValueError("LoRA 모델이 로드되지 않았습니다.")
+            
+            adapter_name = adapter_name or self.current_adapter_name or "default"
+            output_dir = output_dir or str(self.adapters_dir / adapter_name)
+            
+            logger.info(f"💾 LoRA 어댑터 저장 시작: {adapter_name} -> {output_dir}")
+            
+            # 어댑터 저장
+            self.lora_model.save_pretrained(output_dir)
+            
+            # 토크나이저도 저장
+            if self.tokenizer:
+                self.tokenizer.save_pretrained(output_dir)
+            
+            # 어댑터 정보 저장
+            adapter_info = {
+                "adapter_name": adapter_name,
+                "base_model": self.base_model_path,
+                "lora_config": self.lora_config.to_dict() if self.lora_config else None,
+                "created_at": str(torch.tensor(time.time())),
+                "device": self.device
+            }
+            
+            with open(os.path.join(output_dir, "adapter_info.json"), 'w') as f:
+                json.dump(adapter_info, f, indent=2)
+            
+            logger.info(f"✅ LoRA 어댑터 저장 완료: {output_dir}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ LoRA 어댑터 저장 실패: {e}")
+            return False
+    
+    def merge_lora_with_base(self, output_path: str = None) -> bool:
+        """LoRA 어댑터를 기본 모델과 병합"""
+        try:
+            if self.lora_model is None:
+                raise ValueError("LoRA 모델이 로드되지 않았습니다.")
+            
+            output_path = output_path or f"{self.base_model_path}_merged"
+            
+            logger.info(f"🔗 LoRA 어댑터 병합 시작: {output_path}")
+            
+            # 병합된 모델 생성
+            merged_model = self.lora_model.merge_and_unload()
+            
+            # 병합된 모델 저장
+            merged_model.save_pretrained(output_path)
+            
+            # 토크나이저도 저장
+            if self.tokenizer:
+                self.tokenizer.save_pretrained(output_path)
+            
+            logger.info(f"✅ LoRA 어댑터 병합 완료: {output_path}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ LoRA 어댑터 병합 실패: {e}")
+            return False
+    
+    def list_available_adapters(self) -> List[Dict[str, Any]]:
+        """사용 가능한 어댑터 목록 반환"""
+        adapters = []
+        
+        for adapter_dir in self.adapters_dir.iterdir():
+            if adapter_dir.is_dir():
+                config_path = adapter_dir / "adapter_config.json"
+                info_path = adapter_dir / "adapter_info.json"
+                
+                adapter_info = {
+                    "name": adapter_dir.name,
+                    "path": str(adapter_dir),
+                    "config_exists": config_path.exists(),
+                    "info_exists": info_path.exists()
+                }
+                
+                # 어댑터 정보 로드
+                if info_path.exists():
+                    try:
+                        with open(info_path, 'r') as f:
+                            info = json.load(f)
+                        adapter_info.update(info)
+                    except Exception as e:
+                        logger.warning(f"어댑터 정보 로드 실패: {e}")
+                
+                adapters.append(adapter_info)
+        
+        return adapters
+    
+    def get_adapter_stats(self) -> Dict[str, Any]:
+        """어댑터 통계 정보 반환"""
+        if self.lora_model is None:
+            return {"error": "LoRA 모델이 로드되지 않았습니다."}
+        
+        try:
+            # 훈련 가능한 파라미터 수
+            trainable_params = 0
+            all_param = 0
+            
+            for param in self.lora_model.parameters():
+                all_param += param.numel()
+                if param.requires_grad:
+                    trainable_params += param.numel()
+            
+            return {
+                "adapter_name": self.current_adapter_name,
+                "trainable_params": trainable_params,
+                "all_params": all_param,
+                "trainable_ratio": trainable_params / all_param if all_param > 0 else 0,
+                "device": self.device,
+                "model_type": type(self.lora_model).__name__
+            }
+            
+        except Exception as e:
+            logger.error(f"어댑터 통계 수집 실패: {e}")
+            return {"error": str(e)}
+    
+    def switch_adapter(self, adapter_name: str) -> bool:
+        """다른 어댑터로 전환"""
+        try:
+            if adapter_name not in self.loaded_adapters:
+                # 어댑터 로드
+                adapter_path = self.adapters_dir / adapter_name
+                if not adapter_path.exists():
+                    raise FileNotFoundError(f"어댑터를 찾을 수 없습니다: {adapter_name}")
+                
+                return self.load_lora_adapter(str(adapter_path), adapter_name)
+            else:
+                # 이미 로드된 어댑터 사용
+                self.current_adapter_name = adapter_name
+                logger.info(f"🔄 어댑터 전환: {adapter_name}")
+                return True
+                
+        except Exception as e:
+            logger.error(f"❌ 어댑터 전환 실패: {e}")
+            return False
+    
+    def unload_adapter(self) -> bool:
+        """LoRA 어댑터 언로드"""
+        try:
+            if self.lora_model is None:
+                return True
+            
+            logger.info("🗑️ LoRA 어댑터 언로드 시작")
+            
+            # 어댑터 제거
+            self.lora_model = None
+            self.current_adapter_name = None
+            self.lora_config = None
+            
+            logger.info("�� LoRA 어댑터 언로드 완료")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ LoRA 어댑터 언로드 실패: {e}")
+            return False
+    
+    def generate_text(self, prompt: str, max_length: int = 100, temperature: float = 0.7) -> str:
+        """LoRA 모델을 사용한 텍스트 생성"""
+        try:
+            if self.lora_model is None:
+                raise ValueError("LoRA 모델이 로드되지 않았습니다.")
+            
+            if self.tokenizer is None:
+                raise ValueError("토크나이저가 로드되지 않았습니다.")
+            
+            # 입력 토크나이징
+            inputs = self.tokenizer(prompt, return_tensors="pt")
+            
+            # token_type_ids 제거 (PEFT 모델에서 지원하지 않음)
+            if 'token_type_ids' in inputs:
+                del inputs['token_type_ids']
+                logger.info("🔍 token_type_ids 제거됨 (PEFT 모델 호환성)")
+            
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+            
+            # 추론 모드로 설정
+            self.lora_model.eval()
+            
+            with torch.no_grad():
+                outputs = self.lora_model.generate(
+                    **inputs,
+                    max_new_tokens=max_length,
+                    temperature=temperature,
+                    do_sample=True,
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+            
+            # 응답 디코딩
+            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            # 프롬프트 제거
+            if response.startswith(prompt):
+                response = response[len(prompt):].strip()
+            
+            return response
+            
+        except Exception as e:
+            logger.error(f"❌ 텍스트 생성 실패: {e}")
+            return f"텍스트 생성 중 오류가 발생했습니다: {str(e)}"
+    
+    def prepare_for_training(self, training_args: TrainingArguments = None) -> bool:
+        """훈련을 위한 모델 준비"""
+        try:
+            if self.lora_model is None:
+                raise ValueError("LoRA 모델이 로드되지 않았습니다.")
+            
+            logger.info("🔧 훈련을 위한 모델 준비 시작")
+            
+            # 기본 훈련 인수
+            if training_args is None:
+                training_args = TrainingArguments(
+                    output_dir="./lora_training_output",
+                    num_train_epochs=3,
+                    per_device_train_batch_size=4,
+                    gradient_accumulation_steps=4,
+                    learning_rate=2e-4,
+                    warmup_steps=100,
+                    logging_steps=10,
+                    save_steps=500,
+                    eval_steps=500,
+                    evaluation_strategy="steps",
+                    save_strategy="steps",
+                    load_best_model_at_end=True,
+                    metric_for_best_model="eval_loss",
+                    greater_is_better=False,
+                    fp16=torch.cuda.is_available(),
+                    dataloader_pin_memory=False,
+                )
+            
+            # 훈련 모드로 설정
+            self.lora_model.train()
+            
+            # 그래디언트 체크포인팅 활성화 (메모리 절약)
+            self.lora_model.gradient_checkpointing_enable()
+            
+            # 그래디언트 클리핑 설정
+            self.lora_model.enable_input_require_grads()
+            
+            logger.info("✅ 훈련을 위한 모델 준비 완료")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ 훈련 준비 실패: {e}")
+            return False
+
+# 전역 LoRA 관리자 인스턴스 (안전한 생성)
+try:
+    if PEFT_AVAILABLE and TRANSFORMERS_AVAILABLE:
+        lora_manager = LoRAManager()
+        logger.info("✅ 전역 LoRA 관리자 인스턴스 생성 완료")
+    else:
+        lora_manager = None
+        logger.warning("⚠️ LoRA 라이브러리가 사용 불가능하여 LoRA 관리자를 생성하지 않았습니다.")
+except Exception as e:
+    lora_manager = None
+    logger.error(f"❌ LoRA 관리자 인스턴스 생성 실패: {e}")
+
+def get_lora_manager() -> Optional[LoRAManager]:
+    """전역 LoRA 관리자 반환 (None일 수 있음)"""
+    return lora_manager