Auto commit at 22-2025-08 21:22:44

lily_llm_api/models/kanana_1_5_v_3b_instruct.py

@@ -127,6 +127,7 @@ class Kanana15V3bInstructProfile:
 
             processor = AutoProcessor.from_pretrained(
                 model_path,
+                token=HF_TOKEN, 
                 trust_remote_code=True,
                 local_files_only=use_local,
                 use_fast=True  # 🔄 빠른 이미지 프로세서 사용 (경고 제거)
@@ -134,16 +135,17 @@ class Kanana15V3bInstructProfile:
 
             device = 'cuda' if torch.cuda.is_available() else 'cpu'
             
-            # dtype 설정 최적화 - CPU에서는 float32 사용
+            # 공식 설정 파일 bfloat16 사용, float32 사용시 메모리 에러 발생
             if device == 'cuda':
-                selected_dtype = torch.bfloat16  # GPU에서는 float16으로 메모리 절약
+                selected_dtype = torch.bfloat16
             else:
-                selected_dtype = torch.bfloat16  # CPU에서는 float32로 안정성 확보
+                selected_dtype = torch.bfloat16
                 
             logger.info(f"🔧 선택된 dtype: {selected_dtype} (device: {device})")
 
             model = AutoModelForVision2Seq.from_pretrained(
                 model_path,
+                token=HF_TOKEN, 
                 trust_remote_code=True,
                 torch_dtype=selected_dtype,
                 local_files_only=use_local,                
@@ -168,9 +170,9 @@ class Kanana15V3bInstructProfile:
         return {
             "max_new_tokens": 128,
             "do_sample": True,
-            "temperature": 0.9,
+            "temperature": 0.7,
             "top_k": 50,
-            "top_p": 0.95,
+            "top_p": 0.9,
             "repetition_penalty": 1.1,
             "no_repeat_ngram_size": 3,
             "pad_token_id": 128001,

lily_llm_api/models/polyglot_ko_1_3b_chat.py

@@ -267,6 +267,7 @@ class PolyglotKo13bChatProfile:
             "no_repeat_ngram_size": 3,       # 2 → 3으로 조정
             "pad_token_id": 2,               # 공식 설정 사용
             "eos_token_id": 2,               # 공식 설정 사용
+            "bos_token_id": 0,               # 공식 설정 사용
             "use_cache": True,               # 캐시 활성화 (속도 향상)
             "early_stopping": False,         # EOS 토큰까지 생성하도록 설정
         }

lily_llm_core/lora_manager.py

@@ -148,6 +148,20 @@ class LoRAManager:
                 self.tokenizer.pad_token = self.tokenizer.eos_token
             
             # 모델 로드
+            # 모델 타입에 따른 dtype 결정
+            # if model_type in ['kanana-1.5-v-3b-instruct', 'vision2seq']:
+            #     selected_dtype = torch.bfloat16 if self.device == "cuda" else torch.bfloat16
+            #     logger.info(f"🔍 [DEBUG] Kanana 모델 감지: {model_type} -> bfloat16 사용")
+            # elif model_type in ['polyglot-ko-1.3b-chat', 'causal_lm']:
+            #     selected_dtype = torch.float16 if self.device == "cuda" else torch.float32
+            #     logger.info(f"🔍 [DEBUG] 일반 모델 감지: {model_type} -> {selected_dtype} 사용")
+            # elif model_type in ['polyglot-ko-5.8b-chat', 'causal_lm']:
+            #     selected_dtype = torch.bfloat16 if self.device == "cuda" else torch.bfloat16
+            #     logger.info(f"🔍 [DEBUG] 일반 모델 감지: {model_type} -> {selected_dtype} 사용")
+            # else:
+            #     # 🔄 기타 모델: 기존 로직 사용
+            #     selected_dtype = torch.float16 if self.device == "cuda" else torch.float16
+            
             if model_type == "causal_lm":
                 self.base_model = AutoModelForCausalLM.from_pretrained(
                     str(model_path),
@@ -157,7 +171,7 @@ class LoRAManager:
                     device_map="auto" if self.device == "cuda" else None
                 )
             elif model_type == "vision2seq":
-                # 🔄 Vision2Seq 모델 지원 추가 (kanana 등)
+                # 🔄 Vision2Seq 모델 지원 추가 (kanana 등, bfloat16 사용)
                 from transformers import AutoModelForVision2Seq
                 self.base_model = AutoModelForVision2Seq.from_pretrained(
                     str(model_path),
@@ -288,17 +302,23 @@ class LoRAManager:
             # 🔄 모델 타입에 따른 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']:
+                if model_type in ['kanana-1.5-v-3b-instruct', 'vision2seq']:
                     # 🔄 Kanana 모델: bfloat16 사용
-                    selected_dtype = torch.bfloat16
+                    selected_dtype = torch.bfloat16 if self.device == "cuda" else torch.bfloat16
                     logger.info(f"🔍 [DEBUG] Kanana 모델 감지: {model_type} -> bfloat16 사용")
+                elif model_type in ['polyglot-ko-1.3b-chat', 'causal_lm']:
+                    selected_dtype = torch.float16 if self.device == "cuda" else torch.float32
+                    logger.info(f"🔍 [DEBUG] 일반 모델 감지: {model_type} -> {selected_dtype} 사용")
+                elif model_type in ['polyglot-ko-5.8b-chat', 'causal_lm']:
+                    selected_dtype = torch.bfloat16 if self.device == "cuda" else torch.bfloat16
+                    logger.info(f"🔍 [DEBUG] 일반 모델 감지: {model_type} -> {selected_dtype} 사용")                    
                 else:
                     # 🔄 기타 모델: 기존 로직 사용
-                    selected_dtype = torch.float16 if self.device == "cuda" else torch.float32
+                    selected_dtype = torch.float16 if self.device == "cuda" else torch.float16
                     logger.info(f"🔍 [DEBUG] 일반 모델 감지: {model_type} -> {selected_dtype} 사용")
             else:
                 # 🔄 모델 타입을 알 수 없는 경우: 기존 로직 사용
-                selected_dtype = torch.float16 if self.device == "cuda" else torch.float32
+                selected_dtype = torch.float16 if self.device == "cuda" else torch.float16
                 logger.info(f"🔍 [DEBUG] 모델 타입 미확인 -> {selected_dtype} 사용")
             
             # LoRA 어댑터 로드 (모델별 최적 dtype 사용)

lily_llm_core/lora_manager_250822_1812.py

@@ -1,589 +0,0 @@
-#!/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 

test_cos.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65aaa9057a45c5c3d63d425ac56f2eb23bb0688420548179a2ea951afdc0b9d7
+size 212382

test_design.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab9559d67982f525582ced9415fe63c13ce7084401ac02d3459000f44bd7e4ef
+size 424879

test_math.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b74be60ccf89d7174365abb6ce2ade4c04b197fa77c1d32c74e5cdbb782ccf0f
+size 174502