# -*- coding: utf-8 -*- """ GPU 상태 확인 및 설치 가이드 모듈 기능: - NVIDIA GPU 감지 - CUDA Toolkit 설치 확인 - cuDNN 설치 확인 - TensorRT 설치 확인 - cuDNN PATH 자동 설정 - 설치 가이드 제공 """ import os import subprocess import platform import logging from typing import Dict, List, Optional, Tuple from pathlib import Path import glob import json class GPUStatusChecker: """GPU 환경 상태를 종합적으로 확인하고 설치 가이드를 제공하는 클래스""" def __init__(self, logger: Optional[object] = None): self.logger = logger or self._create_dummy_logger() self.status = {} def _create_dummy_logger(self): """로거가 없을 때 사용할 더미 로거""" class DummyLogger: def log(self, msg, level=logging.INFO, exc_info=False): print(f"[GPU_CHECK] {msg}") return DummyLogger() def check_all_gpu_components(self) -> Dict[str, any]: """모든 GPU 관련 구성요소를 확인하고 상태 반환""" self.status = { 'nvidia_gpu': self._check_nvidia_gpu(), 'cuda_toolkit': self._check_cuda_toolkit(), 'cudnn': self._check_cudnn(), 'tensorrt': self._check_tensorrt(), 'onnxruntime_gpu': self._check_onnxruntime_gpu(), 'path_configured': self._check_path_configuration(), 'recommendations': [] } # 권장사항 생성 self._generate_recommendations() return self.status def _check_nvidia_gpu(self) -> Dict[str, any]: """NVIDIA GPU 및 드라이버 확인 (상세 정보 포함)""" try: result = subprocess.run( ["nvidia-smi", "--query-gpu=name,driver_version,memory.total,compute_cap", "--format=csv,noheader"], capture_output=True, text=True, timeout=10, creationflags=subprocess.CREATE_NO_WINDOW if platform.system() == "Windows" else 0 ) if result.returncode == 0: lines = result.stdout.strip().split('\n') gpus = [] for i, line in enumerate(lines): if line.strip(): parts = [p.strip() for p in line.split(',')] if len(parts) >= 3: gpu_info = { 'id': i, 'name': parts[0], 'driver_version': parts[1], 'memory_mb': parts[2].replace(' MiB', ''), 'compute_capability': parts[3] if len(parts) > 3 else 'Unknown', 'architecture': self._detect_gpu_architecture(parts[0]), 'cuda_support': self._check_cuda_compatibility(parts[0]) } gpus.append(gpu_info) return { 'installed': True, 'gpus': gpus, 'count': len(gpus), 'message': f"{len(gpus)}개의 NVIDIA GPU 감지됨", 'primary_gpu': gpus[0] if gpus else None } else: return { 'installed': False, 'gpus': [], 'count': 0, 'message': "NVIDIA GPU 또는 드라이버가 설치되지 않음" } except (subprocess.TimeoutExpired, FileNotFoundError): return { 'installed': False, 'gpus': [], 'count': 0, 'message': "nvidia-smi 명령을 찾을 수 없음 (NVIDIA 드라이버 미설치)" } except Exception as e: return { 'installed': False, 'gpus': [], 'count': 0, 'message': f"GPU 확인 중 오류: {e}" } def _detect_gpu_architecture(self, gpu_name: str) -> str: """GPU 이름을 기반으로 아키텍처 감지""" gpu_name_lower = gpu_name.lower() # RTX 40 시리즈 (Ada Lovelace) if any(model in gpu_name_lower for model in ['rtx 40', 'rtx 41', 'rtx 42', 'rtx 43', 'rtx 44']): return 'Ada Lovelace (RTX 40 시리즈)' # RTX 30 시리즈 (Ampere) elif any(model in gpu_name_lower for model in ['rtx 30', 'rtx 31', 'rtx 32', 'rtx 33', 'rtx 34']): return 'Ampere (RTX 30 시리즈)' # RTX 20 시리즈 (Turing) elif any(model in gpu_name_lower for model in ['rtx 20', 'rtx 21', 'rtx 22', 'rtx 23', 'rtx 24']): return 'Turing (RTX 20 시리즈)' # GTX 16 시리즈 (Turing) elif any(model in gpu_name_lower for model in ['gtx 16', 'gtx 165', 'gtx 166']): return 'Turing (GTX 16 시리즈)' # GTX 10 시리즈 (Pascal) elif any(model in gpu_name_lower for model in ['gtx 10', 'gtx 105', 'gtx 106', 'gtx 107', 'gtx 108']): return 'Pascal (GTX 10 시리즈)' # GTX 900 시리즈 (Maxwell) elif any(model in gpu_name_lower for model in ['gtx 9', 'gtx 90']): return 'Maxwell (GTX 900 시리즈)' # Quadro 카드들 elif 'quadro' in gpu_name_lower: return 'Quadro 워크스테이션' # Tesla 카드들 elif 'tesla' in gpu_name_lower: return 'Tesla 데이터센터' else: return 'Unknown' def _check_cuda_compatibility(self, gpu_name: str) -> Dict[str, any]: """GPU의 CUDA 12.1 호환성 확인""" gpu_name_lower = gpu_name.lower() # CUDA 12.1을 완전히 지원하는 GPU들 (Compute Capability 6.0 이상) fully_supported = [ 'rtx 40', 'rtx 41', 'rtx 42', 'rtx 43', 'rtx 44', # Ada Lovelace 'rtx 30', 'rtx 31', 'rtx 32', 'rtx 33', 'rtx 34', # Ampere 'rtx 20', 'rtx 21', 'rtx 22', 'rtx 23', 'rtx 24', # Turing 'gtx 16', 'gtx 165', 'gtx 166', # Turing GTX 'gtx 10', 'gtx 105', 'gtx 106', 'gtx 107', 'gtx 108' # Pascal ] # 제한적 지원 (구형 아키텍처) limited_support = [ 'gtx 9', 'gtx 90' # Maxwell ] if any(model in gpu_name_lower for model in fully_supported): return { 'supported': True, 'level': 'full', 'message': 'CUDA 12.1 완전 지원' } elif any(model in gpu_name_lower for model in limited_support): return { 'supported': True, 'level': 'limited', 'message': 'CUDA 12.1 제한적 지원 (구형 아키텍처)' } else: return { 'supported': False, 'level': 'none', 'message': 'CUDA 12.1 지원 여부 확인 필요' } def _check_cuda_toolkit(self) -> Dict[str, any]: """CUDA Toolkit 설치 확인""" try: result = subprocess.run( ["nvcc", "--version"], capture_output=True, text=True, timeout=10, creationflags=subprocess.CREATE_NO_WINDOW if platform.system() == "Windows" else 0 ) if result.returncode == 0: output = result.stdout version_info = "" for line in output.split('\n'): if 'release' in line.lower(): version_info = line.strip() break return { 'installed': True, 'version': version_info, 'message': f"CUDA Toolkit 설치됨: {version_info}" } else: return { 'installed': False, 'version': None, 'message': "CUDA Toolkit이 설치되지 않음" } except (subprocess.TimeoutExpired, FileNotFoundError): return { 'installed': False, 'version': None, 'message': "nvcc 명령을 찾을 수 없음 (CUDA Toolkit 미설치)" } except Exception as e: return { 'installed': False, 'version': None, 'message': f"CUDA Toolkit 확인 중 오류: {e}" } def _check_cudnn(self) -> Dict[str, any]: """cuDNN 설치 확인""" cudnn_paths = [] cudnn_versions = [] # Windows에서 일반적인 cuDNN 설치 경로들 if platform.system() == "Windows": search_paths = [ "C:/Program Files/NVIDIA/CUDNN", "C:/tools/cuda/cudnn", "C:/cudnn" ] # 환경변수에서도 찾기 cuda_path = os.environ.get('CUDA_PATH', '') if cuda_path: search_paths.append(os.path.join(cuda_path, 'cudnn')) for base_path in search_paths: if os.path.exists(base_path): # cuDNN 버전 디렉토리 찾기 version_dirs = glob.glob(os.path.join(base_path, "v*")) for version_dir in version_dirs: bin_dirs = glob.glob(os.path.join(version_dir, "bin", "*")) for bin_dir in bin_dirs: cudnn_dll = os.path.join(bin_dir, "cudnn64_*.dll") dll_files = glob.glob(cudnn_dll) if dll_files: version_name = os.path.basename(version_dir) cuda_version = os.path.basename(bin_dir) cudnn_paths.append({ 'path': bin_dir, 'version': version_name, 'cuda_version': cuda_version, 'dll_files': [os.path.basename(f) for f in dll_files] }) if cudnn_paths: return { 'installed': True, 'paths': cudnn_paths, 'count': len(cudnn_paths), 'message': f"cuDNN 설치됨: {len(cudnn_paths)}개 버전 발견" } else: return { 'installed': False, 'paths': [], 'count': 0, 'message': "cuDNN이 설치되지 않음" } def _check_tensorrt(self) -> Dict[str, any]: """TensorRT 설치 확인""" try: # ONNXRuntime에서 TensorRT provider 확인 import onnxruntime as ort available_providers = ort.get_available_providers() tensorrt_available = 'TensorrtExecutionProvider' in available_providers if tensorrt_available: # TensorRT 설치 경로 찾기 시도 tensorrt_paths = [] if platform.system() == "Windows": search_paths = [ "C:/Program Files/NVIDIA/TensorRT", "C:/TensorRT" ] for path in search_paths: if os.path.exists(path): tensorrt_paths.append(path) return { 'installed': True, 'available_in_onnx': True, 'paths': tensorrt_paths, 'message': "TensorRT 설치됨 (ONNXRuntime에서 사용 가능)" } else: return { 'installed': False, 'available_in_onnx': False, 'paths': [], 'message': "TensorRT가 설치되지 않음 또는 ONNXRuntime에서 인식되지 않음" } except ImportError: return { 'installed': False, 'available_in_onnx': False, 'paths': [], 'message': "ONNXRuntime이 설치되지 않아 TensorRT 확인 불가" } except Exception as e: return { 'installed': False, 'available_in_onnx': False, 'paths': [], 'message': f"TensorRT 확인 중 오류: {e}" } def _check_onnxruntime_gpu(self) -> Dict[str, any]: """ONNXRuntime GPU 지원 확인""" try: import onnxruntime as ort available_providers = ort.get_available_providers() gpu_providers = [] if 'CUDAExecutionProvider' in available_providers: gpu_providers.append('CUDA') if 'TensorrtExecutionProvider' in available_providers: gpu_providers.append('TensorRT') return { 'installed': True, 'gpu_providers': gpu_providers, 'all_providers': available_providers, 'message': f"ONNXRuntime GPU 지원: {', '.join(gpu_providers) if gpu_providers else 'CPU만 지원'}" } except ImportError: return { 'installed': False, 'gpu_providers': [], 'all_providers': [], 'message': "ONNXRuntime이 설치되지 않음" } except Exception as e: return { 'installed': False, 'gpu_providers': [], 'all_providers': [], 'message': f"ONNXRuntime 확인 중 오류: {e}" } def _check_path_configuration(self) -> Dict[str, any]: """PATH 환경변수에 cuDNN이 설정되어 있는지 확인""" current_path = os.environ.get('PATH', '') cudnn_in_path = [] # cuDNN 상태를 직접 확인 (self.status가 아직 완전하지 않을 수 있음) cudnn_status = self._check_cudnn() if cudnn_status.get('installed', False): cudnn_paths = cudnn_status['paths'] path_parts = current_path.split(os.pathsep) for cudnn_info in cudnn_paths: cudnn_bin_path = cudnn_info['path'] # PATH에 있는지 더 정확하게 확인 path_exists = any( os.path.normpath(part.strip()) == os.path.normpath(cudnn_bin_path) for part in path_parts if part.strip() ) if path_exists: cudnn_in_path.append(cudnn_info) return { 'cudnn_in_path': len(cudnn_in_path) > 0, 'configured_paths': cudnn_in_path, 'message': f"PATH 설정: {'올바름' if cudnn_in_path else 'cuDNN 경로 누락'}" } def _generate_recommendations(self): """현재 상태에 따른 권장사항 생성""" recommendations = [] # NVIDIA GPU 확인 if not self.status['nvidia_gpu']['installed']: recommendations.append({ 'priority': 'critical', 'component': 'NVIDIA GPU', 'action': 'NVIDIA GPU 드라이버 설치', 'description': 'NVIDIA 공식 사이트에서 최신 드라이버를 다운로드하여 설치하세요.', 'url': 'https://www.nvidia.com/drivers/' }) # CUDA Toolkit 확인 if not self.status['cuda_toolkit']['installed']: recommendations.append({ 'priority': 'critical', 'component': 'CUDA Toolkit', 'action': 'CUDA Toolkit 12.1 설치', 'description': 'NVIDIA CUDA Toolkit 12.1을 설치하세요.', 'url': 'https://developer.nvidia.com/cuda-toolkit-archive' }) # cuDNN 확인 if not self.status['cudnn']['installed']: recommendations.append({ 'priority': 'critical', 'component': 'cuDNN', 'action': 'cuDNN v9.x 설치', 'description': 'NVIDIA cuDNN v9.x를 다운로드하여 설치하세요.', 'url': 'https://developer.nvidia.com/cudnn' }) elif not self.status['path_configured']['cudnn_in_path']: recommendations.append({ 'priority': 'high', 'component': 'cuDNN PATH', 'action': 'cuDNN PATH 환경변수 설정', 'description': 'cuDNN bin 디렉토리를 시스템 PATH에 추가하세요.', 'auto_fix': True }) # TensorRT 확인 (선택사항) if not self.status['tensorrt']['installed']: recommendations.append({ 'priority': 'medium', 'component': 'TensorRT', 'action': 'TensorRT 설치 (선택사항)', 'description': 'TensorRT를 설치하면 최고 성능의 GPU 가속을 사용할 수 있습니다.', 'url': 'https://developer.nvidia.com/tensorrt' }) # ONNXRuntime GPU 확인 if not self.status['onnxruntime_gpu']['installed']: recommendations.append({ 'priority': 'critical', 'component': 'ONNXRuntime GPU', 'action': 'onnxruntime-gpu 설치', 'description': 'pip install onnxruntime-gpu 명령으로 설치하세요.', 'command': 'pip install onnxruntime-gpu' }) self.status['recommendations'] = recommendations def auto_fix_cudnn_path(self) -> bool: """cuDNN PATH를 자동으로 설정""" try: # 현재 상태 다시 확인 cudnn_status = self._check_cudnn() if not cudnn_status.get('installed', False): self.logger.log("cuDNN이 설치되지 않아 PATH 설정을 할 수 없습니다", level=logging.ERROR) return False cudnn_paths = cudnn_status['paths'] if not cudnn_paths: self.logger.log("cuDNN 설치 경로를 찾을 수 없습니다", level=logging.ERROR) return False # 가장 최신 버전의 cuDNN 경로 선택 latest_cudnn = max(cudnn_paths, key=lambda x: x['version']) cudnn_bin_path = latest_cudnn['path'] self.logger.log(f"cuDNN 경로 확인됨: {cudnn_bin_path}", level=logging.INFO) # 현재 세션의 PATH에 추가 current_path = os.environ.get('PATH', '') # PATH에 이미 있는지 더 정확하게 확인 path_parts = current_path.split(os.pathsep) path_already_exists = any( os.path.normpath(part.strip()) == os.path.normpath(cudnn_bin_path) for part in path_parts if part.strip() ) if not path_already_exists: # PATH 맨 앞에 추가 (우선순위 높게) new_path = cudnn_bin_path + os.pathsep + current_path os.environ['PATH'] = new_path self.logger.log(f"✅ cuDNN PATH 추가됨: {cudnn_bin_path}", level=logging.INFO) # 설정 후 DLL 로딩 테스트 test_result = self._test_cudnn_loading(cudnn_bin_path) if test_result: self.logger.log("✅ cuDNN DLL 로딩 테스트 성공", level=logging.INFO) else: self.logger.log("⚠️ cuDNN DLL 로딩 테스트 실패 - 재부팅이 필요할 수 있습니다", level=logging.WARNING) return True else: self.logger.log("cuDNN PATH가 이미 설정되어 있습니다", level=logging.INFO) # 이미 있어도 DLL 로딩 테스트 test_result = self._test_cudnn_loading(cudnn_bin_path) if not test_result: self.logger.log("⚠️ PATH는 설정되어 있지만 cuDNN DLL 로딩에 실패했습니다", level=logging.WARNING) return False return True except Exception as e: self.logger.log(f"cuDNN PATH 설정 실패: {e}", level=logging.ERROR, exc_info=True) return False def _test_cudnn_loading(self, cudnn_bin_path: str) -> bool: """cuDNN DLL 로딩 테스트""" try: import ctypes import glob # cudnn64_*.dll 파일 찾기 dll_pattern = os.path.join(cudnn_bin_path, "cudnn64_*.dll") dll_files = glob.glob(dll_pattern) if not dll_files: self.logger.log(f"cuDNN DLL 파일을 찾을 수 없음: {dll_pattern}", level=logging.WARNING) return False # 첫 번째 DLL 로딩 테스트 dll_file = dll_files[0] try: dll = ctypes.CDLL(dll_file) self.logger.log(f"cuDNN DLL 로딩 성공: {os.path.basename(dll_file)}", level=logging.DEBUG) return True except OSError as e: self.logger.log(f"cuDNN DLL 로딩 실패: {e}", level=logging.WARNING) return False except Exception as e: self.logger.log(f"cuDNN DLL 테스트 중 오류: {e}", level=logging.DEBUG) return False def get_installation_commands(self) -> List[str]: """설치가 필요한 구성요소들의 설치 명령어 반환""" commands = [] for rec in self.status.get('recommendations', []): if rec.get('command'): commands.append(rec['command']) return commands def generate_status_report(self) -> str: """상태 보고서 생성""" report = ["=== GPU 환경 상태 보고서 ===\n"] # NVIDIA GPU gpu_status = self.status.get('nvidia_gpu', {}) report.append(f"🎮 NVIDIA GPU: {'✅' if gpu_status.get('installed') else '❌'}") if gpu_status.get('installed'): for gpu in gpu_status.get('gpus', []): report.append(f" - {gpu['name']} ({gpu['memory_mb']}MB, 드라이버 {gpu['driver_version']})") else: report.append(f" - {gpu_status.get('message', 'Unknown')}") # CUDA Toolkit cuda_status = self.status.get('cuda_toolkit', {}) report.append(f"\n🛠️ CUDA Toolkit: {'✅' if cuda_status.get('installed') else '❌'}") report.append(f" - {cuda_status.get('message', 'Unknown')}") # cuDNN cudnn_status = self.status.get('cudnn', {}) report.append(f"\n🧠 cuDNN: {'✅' if cudnn_status.get('installed') else '❌'}") if cudnn_status.get('installed'): for path_info in cudnn_status.get('paths', []): report.append(f" - {path_info['version']} (CUDA {path_info['cuda_version']})") else: report.append(f" - {cudnn_status.get('message', 'Unknown')}") # TensorRT tensorrt_status = self.status.get('tensorrt', {}) report.append(f"\n🚀 TensorRT: {'✅' if tensorrt_status.get('installed') else '❌'}") report.append(f" - {tensorrt_status.get('message', 'Unknown')}") # ONNXRuntime onnx_status = self.status.get('onnxruntime_gpu', {}) report.append(f"\n📦 ONNXRuntime: {'✅' if onnx_status.get('installed') else '❌'}") if onnx_status.get('installed'): providers = onnx_status.get('gpu_providers', []) report.append(f" - GPU 지원: {', '.join(providers) if providers else 'CPU만'}") else: report.append(f" - {onnx_status.get('message', 'Unknown')}") # PATH 설정 path_status = self.status.get('path_configured', {}) report.append(f"\n⚙️ PATH 설정: {'✅' if path_status.get('cudnn_in_path') else '❌'}") report.append(f" - {path_status.get('message', 'Unknown')}") # 권장사항 recommendations = self.status.get('recommendations', []) if recommendations: report.append(f"\n📋 권장사항 ({len(recommendations)}개):") for i, rec in enumerate(recommendations, 1): priority = rec['priority'].upper() report.append(f" {i}. [{priority}] {rec['action']}") report.append(f" {rec['description']}") return '\n'.join(report) def generate_customized_installation_guide(self) -> str: """감지된 GPU에 맞는 맞춤형 설치 가이드 생성""" gpu_status = self.status.get('nvidia_gpu', {}) primary_gpu = gpu_status.get('primary_gpu') if not gpu_status.get('installed', False) or not primary_gpu: return self._generate_generic_installation_guide() gpu_name = primary_gpu.get('name', 'Unknown GPU') architecture = primary_gpu.get('architecture', 'Unknown') cuda_support = primary_gpu.get('cuda_support', {}) driver_version = primary_gpu.get('driver_version', 'Unknown') memory_mb = primary_gpu.get('memory_mb', 'Unknown') guide_parts = [] # GPU 정보 헤더 guide_parts.append(f""" # 🎮 {gpu_name} 맞춤형 GPU 가속 설치 가이드 ## 📊 감지된 GPU 정보 - **GPU 모델**: {gpu_name} - **아키텍처**: {architecture} - **메모리**: {memory_mb} MB - **드라이버 버전**: {driver_version} - **CUDA 12.1 지원**: {cuda_support.get('message', 'Unknown')} """) # CUDA 호환성에 따른 안내 if cuda_support.get('supported', False): if cuda_support.get('level') == 'full': guide_parts.append(""" ## ✅ 호환성 확인 귀하의 GPU는 CUDA 12.1을 완전히 지원합니다! 최고 성능의 GPU 가속을 사용할 수 있습니다. """) elif cuda_support.get('level') == 'limited': guide_parts.append(""" ## ⚠️ 호환성 확인 귀하의 GPU는 CUDA 12.1을 제한적으로 지원합니다. 기본적인 GPU 가속은 가능하지만 최신 기능은 제한될 수 있습니다. """) else: guide_parts.append(""" ## ❓ 호환성 확인 귀하의 GPU의 CUDA 12.1 호환성을 확인할 수 없습니다. 설치 후 정상 작동 여부를 확인해주세요. """) # 맞춤형 드라이버 링크 driver_link = self._get_driver_download_link(gpu_name) guide_parts.append(f""" ## 🎯 맞춤형 설치 링크 ### 1단계: NVIDIA 드라이버 업데이트 현재 드라이버: **{driver_version}** {driver_link} ### 2단계: CUDA Toolkit 12.1 설치 **권장 버전**: CUDA Toolkit 12.1 (편집알바생 최적화 버전) - 📥 [CUDA 12.1 다운로드](https://developer.nvidia.com/cuda-12-1-0-download-archive) - 설치 시 "Express 설치" 선택 권장 - 환경변수는 자동으로 설정됩니다 ### 3단계: cuDNN v9.x 설치 **권장 버전**: cuDNN v9.12 for CUDA 12.1 - 📥 [cuDNN 다운로드](https://developer.nvidia.com/cudnn) (NVIDIA 계정 필요) - **Windows 설치 파일**: `cudnn-windows-x86_64-9.x.x.x_cuda12.exe` - **설치 방법**: 다운로드한 .exe 파일을 실행하여 자동 설치 - **자동 설정**: 설치 후 PATH 환경변수 자동 설정됨 ### 4단계: 프로그램 실행 - 프로그램을 실행하면 자동으로 GPU 가속 상태를 확인합니다 - 별도의 Python 패키지 설치가 필요하지 않습니다 """) # GPU별 성능 최적화 팁 optimization_tips = self._get_optimization_tips(gpu_name, architecture, memory_mb) guide_parts.append(optimization_tips) # 설치 확인 방법 guide_parts.append(""" ## 🧪 설치 확인 설치 완료 후 다음 버튼들을 클릭하여 확인: - **🎮 GPU 상태 확인**: nvidia-smi 명령 실행 - **🔧 CUDA 버전 확인**: nvcc --version 명령 실행 - **🐍 ONNXRuntime GPU 확인**: 프로그램 내 GPU 가속 지원 확인 또는 직접 명령 프롬프트에서 확인: ```cmd nvidia-smi # GPU 상태 확인 nvcc --version # CUDA 확인 ``` **참고**: 이 프로그램은 cx_Freeze로 패키징되어 있어 Python 환경 설정이 필요하지 않습니다. ## 🆘 문제 해결 ### "cudnn64_9.dll을 찾을 수 없음" 오류 1. 이 다이얼로그에서 **"⚙️ cuDNN PATH 자동 설정"** 버튼 클릭 2. 또는 수동으로 cuDNN bin 디렉토리를 PATH에 추가 ### 성능이 예상보다 느린 경우 - GPU 온도 확인 (과열 시 성능 저하) - 다른 GPU 사용 프로그램 종료 - 드라이버를 최신 버전으로 업데이트 ### 메모리 부족 오류 - 이미지 크기 줄이기 - 다른 프로그램 종료하여 GPU 메모리 확보 - 배치 크기 조정 (고급 사용자) """) return ''.join(guide_parts).strip() def _get_driver_download_link(self, gpu_name: str) -> str: """GPU에 맞는 드라이버 다운로드 링크 생성""" gpu_name_lower = gpu_name.lower() # RTX 40 시리즈 if any(model in gpu_name_lower for model in ['rtx 40', 'rtx 41', 'rtx 42', 'rtx 43', 'rtx 44']): return """- 📥 [RTX 40 시리즈 최신 드라이버](https://www.nvidia.com/drivers/results/218194/) - **권장**: Game Ready Driver 또는 Studio Driver 최신 버전""" # RTX 30 시리즈 elif any(model in gpu_name_lower for model in ['rtx 30', 'rtx 31', 'rtx 32', 'rtx 33', 'rtx 34']): return """- 📥 [RTX 30 시리즈 최신 드라이버](https://www.nvidia.com/drivers/results/218194/) - **권장**: Game Ready Driver 또는 Studio Driver 최신 버전""" # RTX 20 시리즈 elif any(model in gpu_name_lower for model in ['rtx 20', 'rtx 21', 'rtx 22', 'rtx 23', 'rtx 24']): return """- 📥 [RTX 20 시리즈 최신 드라이버](https://www.nvidia.com/drivers/results/218194/) - **권장**: Game Ready Driver 최신 버전""" # GTX 16 시리즈 elif any(model in gpu_name_lower for model in ['gtx 16', 'gtx 165', 'gtx 166']): return """- 📥 [GTX 16 시리즈 최신 드라이버](https://www.nvidia.com/drivers/results/218194/) - **권장**: Game Ready Driver 최신 버전""" # GTX 10 시리즈 elif any(model in gpu_name_lower for model in ['gtx 10', 'gtx 105', 'gtx 106', 'gtx 107', 'gtx 108']): return """- 📥 [GTX 10 시리즈 최신 드라이버](https://www.nvidia.com/drivers/results/218194/) - **참고**: 구형 GPU이므로 최신 기능 일부가 제한될 수 있습니다""" # 기타 else: return """- 📥 [NVIDIA 드라이버 자동 감지](https://www.nvidia.com/drivers/) - **방법**: 사이트에서 GPU 모델 선택 후 다운로드""" def _get_optimization_tips(self, gpu_name: str, architecture: str, memory_mb: str) -> str: """GPU별 성능 최적화 팁""" tips = ["\n## 🚀 성능 최적화 팁\n"] try: memory_gb = int(memory_mb) // 1024 if memory_mb.isdigit() else 0 except: memory_gb = 0 # 메모리 기반 최적화 if memory_gb >= 16: tips.append("### 🎯 대용량 메모리 (16GB+) 최적화") tips.append("- **TensorRT 설치 권장**: 최고 성능을 위해 TensorRT 추가 설치") tips.append("- **배치 크기 증가**: 더 큰 이미지나 배치 처리 가능") tips.append("- **동시 처리**: 여러 이미지 동시 처리 가능") elif memory_gb >= 8: tips.append("### ⚡ 중간 메모리 (8-16GB) 최적화") tips.append("- **기본 설정 사용**: 현재 설정이 최적화됨") tips.append("- **메모리 모니터링**: 다른 프로그램과 메모리 공유 주의") elif memory_gb >= 4: tips.append("### 💡 제한적 메모리 (4-8GB) 최적화") tips.append("- **이미지 크기 제한**: 큰 이미지는 성능 저하 가능") tips.append("- **순차 처리**: 동시 처리보다는 순차 처리 권장") tips.append("- **메모리 정리**: 사용 후 자동 메모리 정리 활성화됨") else: tips.append("### ⚠️ 저용량 메모리 (4GB 미만)") tips.append("- **CPU 모드 권장**: GPU 메모리 부족으로 CPU 모드가 더 안정적일 수 있음") tips.append("- **작은 이미지만**: 큰 이미지 처리 시 오류 발생 가능") # 아키텍처별 최적화 if 'Ada Lovelace' in architecture or 'RTX 40' in architecture: tips.append("\n### 🔥 RTX 40 시리즈 특화 최적화") tips.append("- **TensorRT 필수**: RTX 40 시리즈의 성능을 최대화") tips.append("- **AV1 인코딩**: 영상 처리 시 AV1 인코더 활용 가능") elif 'Ampere' in architecture or 'RTX 30' in architecture: tips.append("\n### ⚡ RTX 30 시리즈 특화 최적화") tips.append("- **TensorRT 권장**: 30 시리즈의 RT Core 활용") tips.append("- **DLSS 기술**: AI 가속 기능 최적화됨") elif 'Pascal' in architecture or 'GTX 10' in architecture: tips.append("\n### 🛠️ GTX 10 시리즈 최적화") tips.append("- **기본 CUDA**: TensorRT보다는 기본 CUDA가 안정적") tips.append("- **드라이버 업데이트**: 정기적인 드라이버 업데이트 중요") return '\n'.join(tips) def _generate_generic_installation_guide(self) -> str: """GPU가 감지되지 않은 경우의 일반적인 설치 가이드""" return """ # GPU 가속을 위한 일반 설치 가이드 ## ❓ GPU를 감지할 수 없습니다 NVIDIA GPU가 감지되지 않았습니다. 다음 사항을 확인해주세요: ### 1. GPU 확인 - NVIDIA GPU가 설치되어 있는지 확인 - 장치 관리자에서 디스플레이 어댑터 확인 ### 2. 드라이버 설치 - NVIDIA 공식 사이트에서 드라이버 다운로드 - https://www.nvidia.com/drivers/ ### 3. 일반적인 설치 순서 1. NVIDIA 드라이버 설치 2. CUDA Toolkit 12.1 설치 3. cuDNN v9.x 설치 4. onnxruntime-gpu 설치 자세한 설치 방법은 GPU 설치 후 다시 확인해주세요. """