836 lines
35 KiB
Python
836 lines
35 KiB
Python
# -*- 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 설치 후 다시 확인해주세요.
|
|
"""
|