이미지 로딩 중...
AI Generated
2025. 11. 19. · 2 Views
GPU 환경 구축 및 도구 설치 완벽 가이드
AI 개발을 위한 GPU 환경 구축 방법을 처음부터 끝까지 안내합니다. CUDA 설치부터 PyTorch 설정, 무료 클라우드 GPU 활용까지 실무에서 바로 적용할 수 있는 내용을 담았습니다. 초보자도 쉽게 따라할 수 있도록 단계별로 설명합니다.
목차
- GPU 사양 요구사항 (VRAM 기준)
- CUDA와 cuDNN 설치 가이드
- PyTorch 환경 설정
- Google Colab/Kaggle 무료 GPU 활용
- 로컬 GPU vs 클라우드 GPU 비교
- Conda 가상환경 구축
1. GPU 사양 요구사항 (VRAM 기준)
시작하며
여러분이 처음 AI 모델을 학습시키려고 할 때 이런 상황을 겪어본 적 있나요? 코드를 실행했는데 "CUDA out of memory"라는 에러가 뜨면서 프로그램이 멈춰버리는 상황 말이죠.
몇 시간 동안 준비한 코드가 단 몇 초 만에 실패하는 것을 보면 정말 막막합니다. 이런 문제는 실제 개발 현장에서 정말 자주 발생합니다.
GPU의 메모리(VRAM)가 부족해서 모델을 올리지 못하거나, 학습 중에 메모리가 부족해서 중간에 멈추는 경우가 많죠. 특히 요즘처럼 거대 언어 모델(LLM)을 다루는 시대에는 GPU 메모리가 충분하지 않으면 아예 시작도 할 수 없습니다.
바로 이럴 때 필요한 것이 적절한 GPU 사양 선택입니다. 여러분이 하려는 작업에 맞는 GPU를 선택하면 불필요한 비용을 절약하고, 메모리 부족 문제도 미리 방지할 수 있습니다.
개요
간단히 말해서, GPU 사양 요구사항이란 여러분이 수행하려는 AI 작업에 필요한 최소 GPU 메모리(VRAM) 용량을 의미합니다. 왜 이것이 중요한지 실무 관점에서 설명하자면, GPU는 컴퓨터의 '작업 책상'과 같습니다.
VRAM이 클수록 더 큰 책상에서 더 많은 자료를 펼쳐놓고 작업할 수 있는 것이죠. 예를 들어, GPT-3 같은 거대 모델을 파인튜닝하려면 최소 24GB 이상의 VRAM이 필요한데, 8GB GPU로는 아예 시도조차 할 수 없습니다.
기존에는 비싼 GPU를 무조건 사야 한다고 생각했다면, 이제는 작업 종류에 따라 적절한 사양을 선택할 수 있습니다. 간단한 이미지 분류는 6GB로도 충분하지만, Stable Diffusion 학습은 12GB 이상이 필요합니다.
GPU 사양의 핵심 특징은 크게 세 가지입니다. 첫째, VRAM 용량(6GB, 8GB, 12GB, 24GB 등), 둘째, CUDA 코어 수(연산 속도에 영향), 셋째, 메모리 대역폭(데이터 전송 속도)입니다.
이 중에서도 VRAM 용량이 가장 중요한데, 메모리가 부족하면 아무리 빠른 GPU라도 작업을 수행할 수 없기 때문입니다. 일반적인 작업별 권장 사양을 보면, 딥러닝 입문 학습에는 6-8GB(GTX 1060, RTX 3060), 중급 프로젝트와 이미지 생성에는 12GB(RTX 3060 12GB, RTX 4070), LLM 파인튜닝과 연구용에는 24GB 이상(RTX 3090, RTX 4090, A100)이 필요합니다.
코드 예제
# GPU 메모리 확인 및 모델 로드 가능 여부 체크
import torch
# 현재 사용 가능한 GPU 메모리 확인
def check_gpu_memory():
if torch.cuda.is_available():
# GPU 총 메모리 (GB 단위로 변환)
total_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
# 현재 사용 중인 메모리
allocated_memory = torch.cuda.memory_allocated(0) / 1024**3
# 사용 가능한 메모리
free_memory = total_memory - allocated_memory
print(f"총 GPU 메모리: {total_memory:.2f} GB")
print(f"사용 중인 메모리: {allocated_memory:.2f} GB")
print(f"사용 가능한 메모리: {free_memory:.2f} GB")
return free_memory
else:
print("CUDA를 사용할 수 없습니다.")
return 0
# 실행 예시
available_memory = check_gpu_memory()
설명
이것이 하는 일: 이 코드는 여러분의 컴퓨터에 설치된 GPU의 메모리 상태를 실시간으로 확인하여, 지금 얼마나 많은 메모리를 사용할 수 있는지 알려줍니다. 첫 번째로, torch.cuda.is_available()로 CUDA가 사용 가능한지 확인합니다.
이것은 마치 집에 전기가 들어오는지 확인하는 것과 같습니다. 전기가 없으면 아무것도 할 수 없듯이, CUDA가 없으면 GPU를 사용할 수 없습니다.
그 다음으로, get_device_properties(0).total_memory로 GPU의 전체 메모리 용량을 확인합니다. 여기서 '0'은 첫 번째 GPU를 의미하는데요, 만약 여러 개의 GPU가 있다면 1, 2, 3...
으로 다른 GPU도 확인할 수 있습니다. 바이트 단위로 나오는 숫자를 1024**3으로 나누면 우리가 이해하기 쉬운 GB 단위로 변환됩니다.
세 번째로, memory_allocated()로 현재 사용 중인 메모리를 확인합니다. 이것은 책상 위에 이미 펼쳐놓은 책과 노트의 양을 세는 것과 같습니다.
전체 공간에서 사용 중인 공간을 빼면 앞으로 사용할 수 있는 여유 공간이 나오겠죠? 여러분이 이 코드를 사용하면 모델을 로드하기 전에 미리 메모리가 충분한지 확인할 수 있습니다.
예를 들어, 10GB가 필요한 모델인데 여유 메모리가 8GB밖에 없다면, 배치 크기를 줄이거나 모델을 경량화하는 등의 조치를 미리 취할 수 있습니다. 이렇게 하면 학습 중간에 메모리 부족으로 실패하는 것을 방지할 수 있고, 시간과 전력을 절약할 수 있습니다.
실전 팁
💡 모델 로드 전에 항상 메모리를 확인하세요. 특히 Hugging Face에서 모델을 다운로드할 때는 모델 카드에 표시된 권장 VRAM을 꼭 확인하고, 여유분 2-3GB를 더 고려해야 합니다.
💡 "CUDA out of memory" 에러가 발생하면 당황하지 말고 배치 크기를 절반으로 줄여보세요. 예를 들어 batch_size=32에서 에러가 나면 16, 8, 4로 점차 줄이면서 테스트하면 대부분 해결됩니다.
💡 torch.cuda.empty_cache()를 사용하면 사용하지 않는 메모리를 정리할 수 있습니다. 하지만 이것은 Python의 가비지 컬렉션처럼 즉시 실행되지 않을 수 있으니, 학습 루프 시작 전에 한 번 호출하는 것이 좋습니다.
💡 여러 모델을 순차적으로 실행할 때는 이전 모델을 del model로 삭제하고 empty_cache()를 호출하여 메모리를 확실하게 비워야 합니다. 안 그러면 첫 번째 모델의 메모리가 계속 차지되어 두 번째 모델을 로드할 수 없습니다.
💡 Mixed Precision Training(FP16)을 사용하면 메모리 사용량을 거의 절반으로 줄일 수 있습니다. torch.cuda.amp의 autocast를 사용하면 코드 몇 줄만 추가해도 적용할 수 있어서 매우 효율적입니다.
2. CUDA와 cuDNN 설치 가이드
시작하며
여러분이 PyTorch나 TensorFlow를 설치하고 GPU로 코드를 실행하려고 할 때 이런 에러를 본 적 있나요? "CUDA driver version is insufficient" 또는 "Could not load dynamic library 'cudnn64_8.dll'" 같은 메시지가 뜨면서 GPU를 사용하지 못하는 상황 말이죠.
이런 문제는 CUDA와 cuDNN이 제대로 설치되지 않았거나, 버전이 맞지 않아서 발생합니다. GPU는 있는데 사용하지 못하는 것만큼 답답한 일이 없죠.
특히 처음 환경을 구축하는 분들은 어떤 버전을 설치해야 할지, 어떤 순서로 설치해야 할지 헷갈려서 몇 시간씩 삽질하는 경우가 많습니다. 바로 이럴 때 필요한 것이 올바른 CUDA와 cuDNN 설치입니다.
이 두 가지는 GPU를 딥러닝에 사용하기 위한 필수 소프트웨어인데, 마치 GPU라는 자동차를 운전하기 위한 운전면허증과 도로 같은 역할을 합니다.
개요
간단히 말해서, CUDA는 NVIDIA GPU에서 병렬 연산을 수행할 수 있게 해주는 플랫폼이고, cuDNN은 딥러닝에 특화된 GPU 가속 라이브러리입니다. 왜 이 둘이 필요한지 실무 관점에서 설명하자면, CPU로 딥러닝을 돌리면 며칠 걸릴 작업이 GPU로는 몇 시간만에 끝날 수 있습니다.
하지만 GPU 하드웨어만으로는 부족하고, CUDA라는 소프트웨어가 있어야 PyTorch나 TensorFlow가 GPU를 인식하고 사용할 수 있습니다. cuDNN은 여기서 한 발 더 나아가, 합성곱(convolution) 연산 같은 딥러닝 필수 연산을 극도로 최적화해줍니다.
기존에는 GPU 연산을 위해 복잡한 C++ 코드를 직접 작성해야 했다면, 이제는 CUDA와 cuDNN이 설치되어 있으면 PyTorch에서 .cuda()나 .to('cuda')만 호출해도 자동으로 GPU 연산이 이루어집니다. CUDA의 핵심 특징은 첫째, NVIDIA GPU 전용 플랫폼이라는 점(AMD GPU는 ROCm 사용), 둘째, 버전 호환성이 중요하다는 점(PyTorch 2.0은 CUDA 11.7 또는 11.8 권장), 셋째, 드라이버와 툴킷이 별도라는 점입니다.
cuDNN은 CUDA 위에서 동작하며, 특히 CNN(합성곱 신경망) 연산을 10배 이상 빠르게 만들어줍니다. 설치 순서가 매우 중요한데, 반드시 1) NVIDIA 그래픽 드라이버 → 2) CUDA Toolkit → 3) cuDNN 순서로 설치해야 합니다.
순서가 바뀌면 인식이 안 되거나 충돌이 발생할 수 있습니다.
코드 예제
# CUDA와 cuDNN 설치 확인 스크립트
import torch
def check_cuda_installation():
print("=== CUDA 설치 확인 ===")
# CUDA 사용 가능 여부
cuda_available = torch.cuda.is_available()
print(f"CUDA 사용 가능: {cuda_available}")
if cuda_available:
# CUDA 버전 확인
print(f"CUDA 버전: {torch.version.cuda}")
# cuDNN 버전 확인
print(f"cuDNN 버전: {torch.backends.cudnn.version()}")
# GPU 개수 및 이름
gpu_count = torch.cuda.device_count()
print(f"사용 가능한 GPU 개수: {gpu_count}")
for i in range(gpu_count):
print(f"GPU {i}: {torch.cuda.get_device_name(i)}")
# 간단한 GPU 연산 테스트
x = torch.rand(3, 3).cuda()
y = torch.rand(3, 3).cuda()
z = x + y
print(f"GPU 연산 테스트 성공: {z.device}")
else:
print("CUDA를 사용할 수 없습니다. 드라이버 및 CUDA를 확인하세요.")
# 실행
check_cuda_installation()
설명
이것이 하는 일: 이 코드는 여러분의 시스템에 CUDA와 cuDNN이 올바르게 설치되었는지 확인하고, GPU를 실제로 사용할 수 있는지 테스트합니다. 첫 번째로, torch.cuda.is_available()로 PyTorch가 CUDA를 인식하는지 확인합니다.
이것이 False로 나오면 CUDA가 설치되지 않았거나, PyTorch가 CPU 전용 버전으로 설치된 것입니다. True가 나와야 다음 단계로 진행할 수 있습니다.
그 다음으로, torch.version.cuda로 설치된 CUDA 버전을 확인합니다. 예를 들어 "11.8"이 출력되면 CUDA 11.8이 설치된 것인데, 이것이 여러분이 설치한 PyTorch 버전과 호환되는지 확인해야 합니다.
PyTorch 공식 사이트에서 "CUDA 11.8"용으로 설치했는데 여기서 다른 버전이 나오면 재설치가 필요합니다. 세 번째로, torch.backends.cudnn.version()으로 cuDNN 버전을 확인합니다.
8000 이상의 숫자가 나오면 cuDNN 8.x 버전이 설치된 것입니다. 그리고 cuda.device_count()로 시스템에 인식된 GPU 개수를 세고, get_device_name()으로 각 GPU의 모델명을 출력합니다.
마지막으로, 실제로 GPU에서 간단한 행렬 덧셈 연산을 수행해봅니다. .cuda()를 호출하면 텐서가 GPU 메모리로 이동하고, 연산도 GPU에서 수행됩니다.
z.device가 'cuda:0'으로 출력되면 성공한 것입니다. 여러분이 이 코드를 실행했을 때 모든 정보가 정상적으로 출력되면 환경 구축이 완벽하게 끝난 것입니다.
만약 중간에 에러가 발생하면 어느 단계에서 문제가 있는지 정확히 파악할 수 있어서, 해결 방향을 쉽게 찾을 수 있습니다. 예를 들어 CUDA는 인식되는데 cuDNN 버전이 안 나오면 cuDNN 설치만 다시 하면 되겠죠.
실전 팁
💡 CUDA Toolkit과 PyTorch 버전은 반드시 매칭해야 합니다. PyTorch 공식 사이트(pytorch.org)의 설치 가이드에서 여러분의 CUDA 버전에 맞는 설치 명령어를 복사해서 사용하세요. 잘못 설치하면 GPU를 인식하지 못합니다.
💡 Windows에서는 CUDA 설치 경로를 환경변수에 자동으로 추가해주지만, Linux는 수동으로 .bashrc나 .zshrc에 PATH를 추가해야 합니다. export PATH=/usr/local/cuda/bin:$PATH를 추가하는 것을 잊지 마세요.
💡 cuDNN은 zip 파일 형태로 다운로드되는데, 압축을 풀고 bin, include, lib 폴더의 내용을 CUDA 설치 경로의 해당 폴더에 복사해야 합니다. 폴더째로 덮어쓰는 게 아니라 내용물을 복사하는 것이 포인트입니다.
💡 여러 CUDA 버전을 동시에 사용해야 한다면 심볼릭 링크로 관리하세요. ln -s /usr/local/cuda-11.8 /usr/local/cuda 명령으로 기본 버전을 지정하고, 필요할 때 링크만 바꾸면 됩니다.
💡 Docker를 사용하면 CUDA 설치 과정을 건너뛸 수 있습니다. nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04 같은 공식 이미지를 사용하면 CUDA와 cuDNN이 이미 설치되어 있어서 바로 사용할 수 있습니다.
3. PyTorch 환경 설정
시작하며
여러분이 딥러닝 프로젝트를 시작할 때 이런 고민을 해본 적 있나요? "PyTorch를 어떻게 설치하지?
pip install torch만 하면 되는 건가?" 그렇게 설치했다가 나중에 GPU가 인식되지 않아서 당황한 경험이 있을 겁니다. 이런 문제는 PyTorch 설치 명령어에 CUDA 버전이 명시되지 않았거나, 잘못된 버전을 설치해서 발생합니다.
또한 numpy, pandas 같은 다른 라이브러리들과의 버전 충돌도 자주 일어나죠. 특히 transformers, accelerate 같은 최신 라이브러리들은 특정 PyTorch 버전 이상을 요구하는 경우가 많아서, 버전 관리가 정말 중요합니다.
바로 이럴 때 필요한 것이 올바른 PyTorch 환경 설정입니다. 단순히 설치하는 것을 넘어서, GPU와 호환되고, 필요한 라이브러리들과 충돌하지 않는 완벽한 환경을 만드는 방법을 알아야 합니다.
개요
간단히 말해서, PyTorch 환경 설정이란 GPU를 활용할 수 있는 PyTorch를 올바른 버전으로 설치하고, 관련 라이브러리들을 함께 구성하는 과정입니다. 왜 이것이 중요한지 실무 관점에서 설명하자면, 잘못 설치된 PyTorch는 CPU로만 동작하거나, 학습 중에 예상치 못한 에러를 발생시킬 수 있습니다.
예를 들어, Hugging Face의 transformers 라이브러리로 BERT를 파인튜닝하려면 PyTorch 1.13 이상이 필요한데, 구버전을 설치하면 일부 기능이 동작하지 않습니다. 기존에는 pip install torch만 실행했다면, 이제는 CUDA 버전을 명시하고, torch, torchvision, torchaudio를 함께 설치하며, requirements.txt로 의존성을 관리하는 방법을 알아야 합니다.
PyTorch 환경의 핵심 특징은 첫째, CUDA 버전별로 다른 설치 명령어를 사용해야 한다는 점, 둘째, torchvision과 torchaudio는 torch 버전과 정확히 매칭되어야 한다는 점, 셋째, conda와 pip 중 하나를 선택해야 한다는 점입니다. 일반적으로 conda가 의존성 관리에서 더 안정적이지만, pip가 더 가볍고 빠릅니다.
실무에서는 가상환경(virtualenv 또는 conda env)을 반드시 사용해야 합니다. 전역에 설치하면 프로젝트마다 다른 버전이 필요할 때 충돌이 발생하기 때문입니다.
예를 들어 프로젝트 A는 PyTorch 1.13을, 프로젝트 B는 2.0을 사용한다면 각각 별도의 가상환경에 설치해야 합니다.
코드 예제
# PyTorch 환경 설정 및 검증 스크립트
import torch
import torchvision
import sys
def setup_pytorch_env():
print("=== PyTorch 환경 정보 ===")
# Python 버전
print(f"Python 버전: {sys.version.split()[0]}")
# PyTorch 버전
print(f"PyTorch 버전: {torch.__version__}")
print(f"TorchVision 버전: {torchvision.__version__}")
# CUDA 설정 확인
print(f"\nCUDA 사용 가능: {torch.cuda.is_available()}")
if torch.cuda.is_available():
print(f"CUDA 버전: {torch.version.cuda}")
print(f"cuDNN 버전: {torch.backends.cudnn.version()}")
print(f"현재 GPU: {torch.cuda.get_device_name(0)}")
# GPU 메모리 설정 테스트
device = torch.device('cuda')
# 작은 텐서로 GPU 작동 확인
x = torch.randn(1000, 1000, device=device)
y = torch.randn(1000, 1000, device=device)
z = torch.matmul(x, y)
print(f"GPU 행렬 곱셈 테스트 성공: {z.shape}")
else:
print("GPU를 사용할 수 없습니다. CPU 모드로 실행됩니다.")
device = torch.device('cpu')
return device
# 환경 설정 실행
device = setup_pytorch_env()
print(f"\n권장 디바이스: {device}")
설명
이것이 하는 일: 이 코드는 설치된 PyTorch 환경의 모든 정보를 출력하고, GPU가 실제로 작동하는지 테스트합니다. 첫 번째로, sys.version으로 Python 버전을 확인합니다.
PyTorch 2.0은 Python 3.8 이상을 요구하므로, 버전이 맞지 않으면 업그레이드가 필요합니다. torch.__version__으로 설치된 PyTorch 버전을 확인하면, 예를 들어 "2.0.1+cu118"처럼 출력되는데, 여기서 cu118은 CUDA 11.8용 빌드라는 뜻입니다.
그 다음으로, CUDA 사용 가능 여부를 확인하고, 가능하다면 상세 정보를 출력합니다. CUDA 버전, cuDNN 버전, GPU 모델명 등이 모두 표시되면 환경 구축이 성공한 것입니다.
만약 torch.cuda.is_available()이 False로 나오면 CPU 전용 버전이 설치된 것이므로, CUDA 지원 버전으로 재설치해야 합니다. 세 번째로, torch.device('cuda')로 GPU 디바이스 객체를 생성합니다.
이것은 앞으로 모든 텐서와 모델을 이 디바이스에 올려서 GPU 연산을 수행하겠다는 의미입니다. device 변수를 만들어두면 나중에 model.to(device), data.to(device) 형태로 편리하게 사용할 수 있습니다.
마지막으로, 1000x1000 크기의 무작위 행렬 두 개를 생성하고 행렬 곱셈(matmul)을 수행합니다. device=device 파라미터를 주면 텐서가 GPU 메모리에 직접 생성되어, CPU에서 GPU로 복사하는 시간을 절약할 수 있습니다.
이 연산이 에러 없이 완료되면 GPU가 정상적으로 작동하는 것입니다. 여러분이 이 코드를 실행하면 현재 환경의 모든 정보를 한눈에 볼 수 있습니다.
새 프로젝트를 시작할 때마다 이 스크립트를 실행해서 환경을 검증하는 습관을 들이면, 나중에 발생할 수 있는 많은 문제를 미리 방지할 수 있습니다. 특히 서버 환경이나 클라우드에서 작업할 때 GPU가 제대로 인식되는지 확인하는 용도로 매우 유용합니다.
실전 팁
💡 PyTorch 공식 홈페이지(pytorch.org)의 설치 가이드를 반드시 사용하세요. OS, 패키지 매니저, Python 버전, CUDA 버전을 선택하면 정확한 설치 명령어가 자동 생성됩니다. 이것을 복사해서 사용하면 버전 불일치 문제가 없습니다.
💡 pip로 설치할 때는 --index-url 옵션이 포함된 명령어를 사용하세요. 예: pip install torch --index-url https://download.pytorch.org/whl/cu118 이렇게 하면 CUDA 11.8용 PyTorch가 정확히 설치됩니다.
💡 torch, torchvision, torchaudio는 항상 한 번에 함께 설치하세요. 따로 설치하면 버전이 맞지 않아서 호환성 문제가 발생할 수 있습니다. 공식 가이드의 명령어에 세 개가 모두 포함되어 있습니다.
💡 설치 후 torch.cuda.is_available()이 False로 나오면 캐시를 지우고 재설치하세요. pip cache purge로 캐시를 삭제하고, pip uninstall torch torchvision torchaudio로 완전히 제거한 후 다시 설치하면 대부분 해결됩니다.
💡 requirements.txt에는 정확한 버전을 명시하세요. torch==2.0.1처럼 ==를 사용하면 정확히 그 버전만 설치되어 재현성이 보장됩니다. >=를 사용하면 나중에 새 버전이 나왔을 때 예상치 못한 문제가 발생할 수 있습니다.
4. Google Colab/Kaggle 무료 GPU 활용
시작하며
여러분이 딥러닝을 공부하고 싶은데 비싼 GPU를 살 돈이 없다면 어떻게 해야 할까요? 또는 노트북에는 GPU가 없는데 급하게 모델을 학습시켜야 하는 상황이라면요?
이럴 때 많은 분들이 포기하거나, CPU로 며칠씩 기다리면서 학습하곤 합니다. 이런 문제는 딥러닝 입문자들이 가장 많이 겪는 어려움 중 하나입니다.
GPU 가격은 수백만 원대이고, 클라우드 GPU는 시간당 비용이 부담스럽죠. 특히 학생이나 개인 개발자들에게는 큰 장벽이 될 수밖에 없습니다.
바로 이럴 때 필요한 것이 Google Colab과 Kaggle의 무료 GPU 서비스입니다. 믿기 어렵겠지만, 이 두 플랫폼은 완전 무료로 GPU를 제공하며, 심지어 Google Colab Pro를 사용하지 않아도 Tesla T4나 P100 같은 고성능 GPU를 사용할 수 있습니다.
개요
간단히 말해서, Google Colab과 Kaggle은 클라우드 환경에서 무료로 GPU를 사용할 수 있는 Jupyter Notebook 기반 플랫폼입니다. 왜 이것이 중요한지 실무 관점에서 설명하자면, 로컬에 GPU가 없어도 브라우저만 있으면 어디서든 딥러닝 모델을 학습시킬 수 있습니다.
예를 들어, BERT를 파인튜닝하거나 Stable Diffusion을 돌려보고 싶을 때, 로컬 환경 구축 없이 Colab 노트북을 열고 바로 시작할 수 있습니다. 게다가 PyTorch, TensorFlow, transformers 같은 주요 라이브러리들이 이미 설치되어 있어서 환경 설정 시간도 절약됩니다.
기존에는 비싼 GPU를 구매하거나 AWS/GCP에서 시간당 비용을 지불해야 했다면, 이제는 무료로 GPU를 사용할 수 있습니다. Colab은 하루 최대 12시간, Kaggle은 주당 30시간의 GPU 사용 시간을 제공합니다.
두 플랫폼의 핵심 특징을 비교하면, Google Colab은 Google Drive와 통합이 잘 되어 있고 사용이 간편하며, T4 GPU(16GB VRAM)를 제공합니다. Kaggle은 P100 GPU(16GB VRAM) 또는 T4 x2를 제공하고, 인터넷 연결이 가능하며(Colab은 일부 제한), 데이터셋 관리가 편리합니다.
둘 다 TPU도 무료로 제공하지만, PyTorch보다는 TensorFlow에 최적화되어 있습니다. 실무 활용 시나리오를 보면, 빠른 프로토타이핑과 튜토리얼 실습에는 Colab이, 대회 참여와 긴 학습 시간이 필요한 경우에는 Kaggle이 더 적합합니다.
두 플랫폼을 번갈아 사용하면 GPU 시간을 최대한 활용할 수 있습니다.
코드 예제
# Google Colab/Kaggle에서 GPU 환경 확인 및 설정
import torch
import subprocess
import os
def setup_cloud_gpu():
"""클라우드 환경에서 GPU 설정 확인"""
# 플랫폼 감지
is_colab = 'COLAB_GPU' in os.environ
is_kaggle = 'KAGGLE_KERNEL_RUN_TYPE' in os.environ
platform = "Google Colab" if is_colab else "Kaggle" if is_kaggle else "로컬"
print(f"=== {platform} 환경 ===\n")
# GPU 정보 확인
if torch.cuda.is_available():
print(f"GPU: {torch.cuda.get_device_name(0)}")
print(f"VRAM: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
print(f"CUDA 버전: {torch.version.cuda}")
# nvidia-smi로 상세 정보 확인
try:
result = subprocess.run(['nvidia-smi'], capture_output=True, text=True)
print("\n=== GPU 상태 ===")
print(result.stdout)
except:
print("nvidia-smi를 실행할 수 없습니다.")
# 간단한 성능 테스트
import time
size = 5000
x = torch.randn(size, size, device='cuda')
start = time.time()
y = torch.matmul(x, x)
torch.cuda.synchronize() # GPU 연산 완료 대기
elapsed = time.time() - start
print(f"\n{size}x{size} 행렬 곱셈: {elapsed:.4f}초")
else:
print("GPU를 사용할 수 없습니다. 런타임 설정을 확인하세요.")
print("Colab: 런타임 > 런타임 유형 변경 > T4 GPU")
print("Kaggle: Settings > Accelerator > GPU T4 x2")
# 실행
setup_cloud_gpu()
설명
이것이 하는 일: 이 코드는 Google Colab이나 Kaggle에서 실행될 때 현재 사용 중인 GPU의 정보를 확인하고, 간단한 성능 테스트를 수행합니다. 첫 번째로, 환경 변수를 체크하여 현재 어느 플랫폼에서 실행 중인지 감지합니다.
Colab에서는 'COLAB_GPU'라는 환경 변수가, Kaggle에서는 'KAGGLE_KERNEL_RUN_TYPE'이라는 환경 변수가 설정되어 있습니다. 이것을 확인하면 플랫폼별로 다른 최적화를 적용할 수 있습니다.
그 다음으로, torch.cuda.is_available()로 GPU 활성화 여부를 확인합니다. Colab이나 Kaggle에서는 기본적으로 GPU가 비활성화되어 있을 수 있으므로, 런타임 설정에서 GPU를 활성화해야 합니다.
GPU가 활성화되어 있으면 모델명(예: Tesla T4)과 VRAM 용량이 출력됩니다. 세 번째로, nvidia-smi 명령어를 실행하여 GPU의 상세한 상태를 확인합니다.
이 명령어는 GPU 사용률, 온도, 전력 소비, 메모리 사용량 등을 실시간으로 보여주는 시스템 모니터링 도구입니다. subprocess.run()을 사용하면 Python에서 쉘 명령어를 실행하고 결과를 받아올 수 있습니다.
마지막으로, 5000x5000 크기의 대형 행렬 곱셈을 수행하여 GPU 성능을 측정합니다. torch.cuda.synchronize()는 매우 중요한데, GPU 연산은 비동기적으로 실행되기 때문에 이 함수를 호출하지 않으면 실제 연산이 끝나기 전에 시간 측정이 종료될 수 있습니다.
synchronize()를 호출하면 모든 GPU 연산이 완료될 때까지 기다립니다. 여러분이 이 코드를 Colab이나 Kaggle에서 실행하면 할당받은 GPU의 종류와 성능을 즉시 파악할 수 있습니다.
때때로 Colab은 K80(구형)을 할당하기도 하고 T4(신형)를 할당하기도 하는데, 이 스크립트로 확인해서 K80이 나오면 런타임을 재시작하여 T4를 받을 수도 있습니다. 성능 차이가 2-3배까지 날 수 있기 때문에 확인하는 것이 좋습니다.
실전 팁
💡 Google Colab에서 GPU를 활성화하려면 상단 메뉴에서 "런타임 > 런타임 유형 변경 > 하드웨어 가속기"를 T4 GPU로 선택하세요. 기본값은 None(CPU)이므로 반드시 변경해야 합니다.
💡 Colab은 90분 동안 활동이 없으면 세션이 끊어집니다. 긴 학습을 할 때는 중간중간 체크포인트를 Google Drive에 저장하세요. torch.save(model.state_dict(), '/content/drive/MyDrive/checkpoint.pth')로 저장하면 세션이 끊어져도 이어서 학습할 수 있습니다.
💡 Kaggle은 인터넷 연결이 가능하므로 Hugging Face Hub에서 모델을 직접 다운로드할 수 있습니다. Colab은 일부 외부 연결이 차단되어 있어서 미리 다운로드해야 하는 경우가 있습니다.
💡 Colab Pro($9.99/월)를 사용하면 V100 GPU와 더 긴 실행 시간을 얻을 수 있습니다. 하지만 무료 버전도 대부분의 학습에 충분하므로, 먼저 무료 버전을 충분히 활용해보고 필요하면 업그레이드하세요.
💡 Kaggle Notebook에서는 데이터셋을 미리 업로드하면 로딩 속도가 매우 빠릅니다. 매번 인터넷에서 다운로드하는 것보다 Kaggle Dataset으로 등록해두고 사용하는 것이 훨씬 효율적입니다.
5. 로컬 GPU vs 클라우드 GPU 비교
시작하며
여러분이 본격적으로 딥러닝 프로젝트를 시작하려고 할 때 이런 고민을 해본 적 있나요? "GPU를 직접 사야 할까, 아니면 클라우드를 쓸까?" 처음에는 무료 Colab으로 충분했지만, 프로젝트 규모가 커지면서 제한에 부딪히게 됩니다.
이런 선택의 기로에서 많은 분들이 잘못된 결정을 내립니다. 당장 필요하지 않은데 비싼 GPU를 충동 구매하거나, 반대로 클라우드 비용이 눈덩이처럼 불어나서 나중에 후회하는 경우가 많죠.
특히 초기 투자 비용과 장기 운영 비용을 제대로 계산하지 않으면 예산을 초과하게 됩니다. 바로 이럴 때 필요한 것이 로컬 GPU와 클라우드 GPU의 명확한 비교입니다.
여러분의 사용 패턴, 예산, 프로젝트 특성에 따라 최적의 선택이 달라지므로, 각각의 장단점을 정확히 이해해야 합니다.
개요
간단히 말해서, 로컬 GPU는 자신의 컴퓨터에 직접 설치하는 물리적 그래픽 카드이고, 클라우드 GPU는 AWS, GCP, Azure 같은 서비스에서 시간당 요금을 내고 빌리는 가상 GPU입니다. 왜 이 비교가 중요한지 실무 관점에서 설명하자면, 선택에 따라 비용이 수십만 원에서 수백만 원까지 차이 날 수 있습니다.
예를 들어, RTX 4090을 250만 원에 구매하면 2-3년 사용할 수 있지만, AWS p3.2xlarge(V100)는 시간당 약 4,000원이므로 625시간만 사용해도 같은 비용이 듭니다. 하루 8시간씩 사용하면 3개월이면 본전인 셈이죠.
기존에는 무조건 GPU를 구매하는 것이 일반적이었다면, 이제는 사용 패턴에 따라 유연하게 선택할 수 있습니다. 매일 장시간 사용한다면 로컬 GPU가, 가끔 짧게 사용한다면 클라우드가 유리합니다.
로컬 GPU의 핵심 장점은 첫째, 한 번 구매하면 추가 비용 없이 무제한 사용, 둘째, 데이터 프라이버시 보장(로컬에서만 처리), 셋째, 인터넷 속도에 영향을 받지 않음입니다. 단점은 초기 비용이 크고, 업그레이드가 어려우며, 전력 소비와 소음이 발생한다는 점입니다.
클라우드 GPU의 핵심 장점은 첫째, 초기 비용 없이 시작 가능, 둘째, 필요할 때만 사용하고 비용 지불, 셋째, 최신 GPU를 언제든 선택 가능(A100, H100 등), 넷째, 확장성이 뛰어남(여러 GPU 동시 사용)입니다. 단점은 장기 사용 시 비용이 크고, 인터넷 연결이 필수이며, 데이터 전송 비용이 추가로 발생한다는 점입니다.
코드 예제
# 로컬 vs 클라우드 GPU 비용 계산기
def calculate_gpu_cost(usage_hours_per_day, duration_months, local_gpu_price=2500000, cloud_hourly_rate=4000):
"""
GPU 사용 비용을 로컬 구매 vs 클라우드 대여로 비교
Args:
usage_hours_per_day: 하루 평균 사용 시간
duration_months: 사용 예정 기간 (개월)
local_gpu_price: 로컬 GPU 구매 가격 (원, 기본값: RTX 4090)
cloud_hourly_rate: 클라우드 시간당 요금 (원, 기본값: AWS p3.2xlarge)
"""
# 총 사용 시간 계산
total_hours = usage_hours_per_day * 30 * duration_months
# 클라우드 총 비용
cloud_total_cost = total_hours * cloud_hourly_rate
# 로컬 GPU 추가 비용 (전기료: 시간당 약 100원으로 가정)
electricity_cost = total_hours * 100
local_total_cost = local_gpu_price + electricity_cost
# 결과 출력
print(f"=== GPU 비용 비교 ({duration_months}개월, 하루 {usage_hours_per_day}시간 사용) ===\n")
print(f"로컬 GPU:")
print(f" 초기 구매 비용: {local_gpu_price:,}원")
print(f" 전기료 ({total_hours}시간): {electricity_cost:,}원")
print(f" 총 비용: {local_total_cost:,}원")
print(f"\n클라우드 GPU:")
print(f" 시간당 요금: {cloud_hourly_rate:,}원")
print(f" 총 사용 시간: {total_hours:,}시간")
print(f" 총 비용: {cloud_total_cost:,}원")
print(f"\n💰 비용 차이: {abs(local_total_cost - cloud_total_cost):,}원")
if local_total_cost < cloud_total_cost:
savings = cloud_total_cost - local_total_cost
print(f"✅ 로컬 GPU가 {savings:,}원 저렴합니다!")
else:
savings = local_total_cost - cloud_total_cost
print(f"✅ 클라우드 GPU가 {savings:,}원 저렴합니다!")
# 손익분기점 계산
breakeven_hours = local_gpu_price / cloud_hourly_rate
breakeven_days = breakeven_hours / usage_hours_per_day
print(f"\n📊 손익분기점: {breakeven_hours:.0f}시간 ({breakeven_days:.0f}일)")
# 사용 예시
calculate_gpu_cost(usage_hours_per_day=8, duration_months=6)
설명
이것이 하는 일: 이 코드는 여러분의 GPU 사용 패턴을 입력받아서 로컬 GPU 구매와 클라우드 GPU 대여 중 어느 것이 더 경제적인지 자동으로 계산해줍니다. 첫 번째로, 총 사용 시간을 계산합니다.
하루 8시간씩 6개월(180일) 사용한다면 총 1,440시간이 되겠죠. 이 숫자가 비용 계산의 기준이 됩니다.
사용 시간이 많을수록 로컬 GPU가 유리하고, 적을수록 클라우드가 유리합니다. 그 다음으로, 클라우드 GPU의 총 비용을 계산합니다.
AWS p3.2xlarge 인스턴스는 V100 GPU를 제공하며 시간당 약 4,000원입니다. 1,440시간을 사용하면 576만 원이 되는데, 이것은 RTX 4090 구매 가격(250만 원)보다 2배 이상 비싼 금액입니다.
세 번째로, 로컬 GPU의 총 비용을 계산합니다. 여기에는 GPU 구매 비용뿐만 아니라 전기료도 포함됩니다.
고성능 GPU는 350W 정도를 소비하므로, 시간당 약 100원의 전기료가 발생합니다. 1,440시간 사용하면 전기료는 약 14만 원 정도 되지만, 클라우드 비용에 비하면 미미한 수준입니다.
마지막으로, 손익분기점(break-even point)을 계산합니다. RTX 4090이 250만 원, 클라우드가 시간당 4,000원이라면 625시간 사용 시점에서 비용이 같아집니다.
하루 8시간 사용 기준으로 약 78일, 즉 2.5개월이 지나면 로컬 GPU가 더 저렴해지기 시작합니다. 여러분이 이 함수를 사용할 때는 자신의 실제 사용 패턴을 입력하세요.
취미로 주말에만 몇 시간씩 사용한다면(하루 평균 2시간) 클라우드가 유리하고, 연구나 업무로 매일 장시간 사용한다면(하루 10시간 이상) 로컬 GPU를 구매하는 것이 훨씬 경제적입니다. 또한 local_gpu_price와 cloud_hourly_rate 파라미터를 조정하여 다양한 GPU 모델을 비교할 수도 있습니다.
실전 팁
💡 단기 프로젝트(3개월 미만)나 실험적인 작업에는 클라우드를 사용하세요. 예를 들어 새로운 모델 아키텍처를 테스트하는 단계에서는 A100을 며칠만 빌려서 검증하고, 성공하면 로컬 GPU를 구매하는 전략이 효과적입니다.
💡 클라우드를 사용할 때는 Spot Instance(AWS) 또는 Preemptible VM(GCP)을 활용하면 비용을 70% 이상 절약할 수 있습니다. 다만 언제든 중단될 수 있으므로 체크포인트를 자주 저장하는 코드가 필요합니다.
💡 로컬 GPU를 구매할 때는 중고 시장도 고려하세요. RTX 3090은 신품 대비 40-50% 저렴하게 구할 수 있고, 24GB VRAM으로 대부분의 LLM 파인튜닝이 가능합니다. 다만 채굴용으로 사용된 제품은 피하세요.
💡 하이브리드 전략이 가장 현명합니다. 일상적인 개발과 작은 실험은 로컬 GPU로 하고, 거대 모델이나 대규모 학습은 클라우드를 사용하는 방식입니다. 예를 들어 BERT 파인튜닝은 로컬에서, GPT-3 수준의 사전학습은 클라우드에서 진행하면 비용 효율이 극대화됩니다.
💡 클라우드 비용을 추적하려면 알림을 설정하세요. AWS Budgets나 GCP Budget Alerts로 월 예산을 설정하면, 한도에 가까워질 때 이메일로 알려줍니다. GPU를 켜놓고 잊어버려서 수십만 원의 요금 폭탄을 맞는 일을 방지할 수 있습니다.
6. Conda 가상환경 구축
시작하며
여러분이 여러 딥러닝 프로젝트를 동시에 진행할 때 이런 문제를 겪어본 적 있나요? 프로젝트 A에서 PyTorch 1.13을 쓰는데, 프로젝트 B는 PyTorch 2.0이 필요한 상황이죠.
한 시스템에 두 버전을 동시에 설치하려고 하면 충돌이 발생하고, 결국 하나를 포기하거나 매번 재설치해야 합니다. 이런 문제는 실무에서 정말 자주 발생합니다.
라이브러리 버전 충돌, 파이썬 버전 불일치, 의존성 지옥(dependency hell) 등으로 인해 몇 시간씩 환경 설정에 시간을 낭비하게 됩니다. 특히 팀 프로젝트에서는 각자 다른 환경에서 작업하면 "내 컴퓨터에서는 되는데요?"라는 악몽 같은 상황이 벌어지죠.
바로 이럴 때 필요한 것이 Conda 가상환경입니다. 프로젝트마다 독립적인 환경을 만들어서 라이브러리 충돌을 완벽하게 방지하고, 팀원들과 동일한 환경을 쉽게 공유할 수 있습니다.
개요
간단히 말해서, Conda 가상환경은 프로젝트마다 별도의 독립적인 Python 환경을 만들어서 라이브러리 버전 충돌을 방지하는 도구입니다. 왜 이것이 중요한지 실무 관점에서 설명하자면, 가상환경 없이 전역에 모든 라이브러리를 설치하면 나중에 프로젝트를 다시 실행할 때 버전이 바뀌어서 동작하지 않을 수 있습니다.
예를 들어, 6개월 전에 만든 프로젝트를 다시 열었는데 transformers 라이브러리가 업데이트되면서 API가 변경되어 코드가 깨질 수 있습니다. 가상환경을 사용하면 각 프로젝트가 자신만의 라이브러리 버전을 유지하므로 이런 문제가 발생하지 않습니다.
기존에는 virtualenv나 venv를 사용했다면, Conda는 Python 버전까지 프로젝트별로 관리할 수 있어서 더 강력합니다. venv는 Python 버전을 바꿀 수 없지만, Conda는 한 환경은 Python 3.8, 다른 환경은 Python 3.11로 설정할 수 있습니다.
Conda의 핵심 특징은 첫째, Python 버전과 패키지를 모두 격리한다는 점, 둘째, conda 채널을 통해 바이너리 패키지를 제공하여 설치가 빠르다는 점(pip는 소스에서 컴파일하는 경우가 많음), 셋째, environment.yml 파일로 환경을 쉽게 복제할 수 있다는 점입니다. 실무에서는 프로젝트를 시작할 때 가장 먼저 가상환경을 만들고, requirements.txt나 environment.yml에 의존성을 기록합니다.
이렇게 하면 다른 팀원이나 미래의 자신이 정확히 같은 환경을 재현할 수 있습니다. 특히 논문 재현이나 오픈소스 프로젝트 배포 시 필수적입니다.
코드 예제
# Conda 가상환경 생성 및 관리 스크립트
# 터미널에서 실행할 명령어들을 Python 주석으로 설명
# 1. 새로운 가상환경 생성 (Python 3.10, 이름: myproject)
# conda create -n myproject python=3.10 -y
# 2. 가상환경 활성화
# conda activate myproject
# 3. PyTorch 설치 (CUDA 11.8 버전)
# conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia -y
# 4. 추가 라이브러리 설치
# pip install transformers datasets accelerate
# 5. 현재 환경의 패키지 목록 저장
# pip freeze > requirements.txt
# conda env export > environment.yml
# 6. 환경 복제하기 (다른 컴퓨터에서)
# conda env create -f environment.yml
# 7. 환경 목록 확인
# conda env list
# 8. 환경 삭제
# conda remove -n myproject --all -y
# Python 코드로 현재 환경 정보 확인
import sys
import os
def check_conda_env():
"""현재 활성화된 Conda 환경 정보 출력"""
conda_env = os.environ.get('CONDA_DEFAULT_ENV', 'base')
python_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
python_path = sys.executable
print(f"=== Conda 환경 정보 ===")
print(f"환경 이름: {conda_env}")
print(f"Python 버전: {python_version}")
print(f"Python 경로: {python_path}")
if conda_env == 'base':
print("\n⚠️ base 환경에서 작업 중입니다.")
print("프로젝트별 가상환경을 만드는 것을 권장합니다!")
else:
print(f"\n✅ '{conda_env}' 가상환경이 활성화되어 있습니다.")
check_conda_env()
설명
이것이 하는 일: 이 코드는 Conda 가상환경을 생성하고 관리하는 전체 워크플로우를 보여주며, 현재 활성화된 환경의 정보를 확인합니다. 첫 번째로, conda create 명령어로 새로운 가상환경을 만듭니다.
-n myproject는 환경 이름을, python=3.10은 Python 버전을 지정합니다. -y 옵션을 붙이면 확인 프롬프트 없이 자동으로 설치됩니다.
이 명령을 실행하면 독립적인 Python 환경이 생성되는데, 마치 새 컴퓨터를 하나 더 만드는 것과 같습니다. 그 다음으로, conda activate myproject로 생성한 환경을 활성화합니다.
활성화하면 터미널 프롬프트 앞에 (myproject)라고 표시되며, 이제부터 설치하는 모든 패키지는 이 환경에만 설치됩니다. 다른 프로젝트나 base 환경에는 영향을 주지 않습니다.
세 번째로, PyTorch를 설치합니다. Conda를 사용하면 pytorch-cuda=11.8처럼 CUDA 버전을 명시할 수 있어서 호환성 문제가 적습니다.
-c pytorch -c nvidia는 공식 채널에서 다운로드하라는 의미입니다. pip로 설치하는 것보다 Conda로 설치하는 것이 의존성 관리가 더 안정적입니다.
네 번째로, pip freeze와 conda env export로 현재 환경을 파일로 저장합니다. requirements.txt는 pip 패키지만, environment.yml은 Conda 환경 전체(Python 버전 포함)를 저장합니다.
팀원이나 서버에서 conda env create -f environment.yml을 실행하면 똑같은 환경이 재현됩니다. 마지막으로, Python 코드에서 현재 환경을 확인합니다.
CONDA_DEFAULT_ENV 환경 변수를 읽으면 활성화된 환경 이름을 알 수 있습니다. 만약 'base'라면 가상환경을 만들지 않고 작업 중이라는 뜻이므로, 경고 메시지를 출력합니다.
base 환경에서 작업하면 나중에 충돌이 발생할 위험이 높기 때문입니다. 여러분이 새 프로젝트를 시작할 때는 반드시 가장 먼저 가상환경을 만드세요.
프로젝트 이름과 같은 이름으로 환경을 만들면 관리하기 쉽습니다. 예를 들어 "chatbot" 프로젝트라면 conda create -n chatbot python=3.10으로 시작하는 것이죠.
그리고 주기적으로 environment.yml을 업데이트하여 Git에 커밋하면, 팀원들이 항상 최신 환경을 사용할 수 있습니다.
실전 팁
💡 Miniconda를 사용하세요. Anaconda는 불필요한 패키지가 수백 개 포함되어 5GB 이상 차지하지만, Miniconda는 기본 도구만 포함하여 400MB 정도로 가볍습니다. 필요한 패키지만 나중에 설치하면 되므로 Miniconda가 훨씬 효율적입니다.
💡 환경 생성 시 mamba를 사용하면 설치 속도가 10배 이상 빨라집니다. conda install mamba -c conda-forge로 설치하고, conda 대신 mamba create, mamba install을 사용하세요. 특히 복잡한 의존성을 해결할 때 엄청난 시간을 절약할 수 있습니다.
💡 base 환경은 절대 건드리지 마세요. base 환경에 패키지를 설치하면 Conda 자체가 손상될 수 있습니다. 모든 작업은 별도의 가상환경에서 하고, base는 환경 관리 용도로만 사용하세요.
💡 환경 이름에 Python 버전을 포함하면 관리가 쉽습니다. 예: myproject-py310, research-py38 이렇게 하면 conda env list를 실행했을 때 한눈에 어떤 Python 버전을 사용하는지 알 수 있습니다.
💡 사용하지 않는 환경은 주기적으로 삭제하세요. conda env list로 목록을 확인하고, conda remove -n old-project --all로 삭제하면 디스크 공간을 절약할 수 있습니다. 각 환경이 수GB씩 차지하므로, 오래된 프로젝트 환경은 정리하는 것이 좋습니다.