Ver3.5 LLaMA 3 로컬 실행 완전 정복: 내 PC에서 AI를 직접 돌리는 환경 세팅 가이드

LLaMA 3 로컬 실행 완전 정복: 내 PC에서 AI를 직접 돌리는 환경 세팅 가이드
☁️ 클라우드 없이, 요금 걱정 없이 — 내 컴퓨터에서 LLaMA 3를 직접 굴려보자!
설치부터 실행까지, 진짜 쓸 수 있는 실전 가이드 🔥
🦙 LLaMA 3가 뭔데? 왜 로컬에서 돌려야 해?
요즘 ChatGPT, Claude, Gemini 같은 AI 서비스들 진짜 많이 쓰잖아요?
근데 이거 다 클라우드 기반이라서 내 데이터가 서버로 올라가고, 무료 플랜은 제한 있고, 유료 플랜은 돈 나가고... 뭔가 찝찝하지 않음? 🤔
그래서 등장한 게 바로 로컬 LLM(Large Language Model) 실행이에요!
내 컴퓨터에서 직접 AI 모델을 돌리면:
💸 비용 제로 — API 요금? 그런 거 없음ㅋㅋ
⚡ 인터넷 없어도 OK — 오프라인 환경에서도 실행 가능
🛠️ 커스터마이징 자유 — 파인튜닝, 프롬프트 엔지니어링 마음대로
🚀 레이턴시 최소화 — 서버 왕복 없이 로컬에서 바로 처리
그리고 그 중심에 있는 게 바로 Meta AI가 공개한 LLaMA 3입니다!
LLaMA 3 간단 소개
LLaMA(Large Language Model Meta AI)는 Meta(구 Facebook)에서 개발한 오픈소스 대형 언어 모델이에요.
2024년 4월에 LLaMA 3가 공개됐는데, 이전 버전 대비 성능이 엄청 올라갔어요 🔥
| 모델 | 파라미터 수 | 특징 | 용도 |
|---|---|---|---|
| LLaMA 3 8B | 80억 | 가볍고 빠름, 소비자 GPU에서 실행 가능 | 일반 대화, 코드 생성, 요약 |
| LLaMA 3 70B | 700억 | 고성능, 고사양 필요 | 복잡한 추론, 전문 분야 |
| LLaMA 3 405B | 4050억 | 최고 성능, 서버급 하드웨어 필요 | 연구, 기업용 |
일반 개발자나 AI 덕후들이 로컬에서 돌리기에는 8B 모델이 가장 현실적이에요.
70B도 양자화(Quantization)하면 어느 정도 돌아가긴 하는데, 이건 뒤에서 자세히 설명할게요!
💻 내 PC 스펙이 되는지 먼저 확인해보자
LLaMA 3 로컬 실행에서 제일 중요한 게 하드웨어 스펙이에요.
"내 컴퓨터로 될까?" 이게 제일 먼저 드는 의문이잖아요ㅋㅋㅋ 바로 확인해봅시다!
핵심 요소: GPU VRAM이 왕이다 👑
LLM을 실행할 때 가장 중요한 건 GPU의 VRAM(비디오 메모리)이에요.
모델 파라미터가 전부 VRAM에 올라가야 빠르게 돌아가거든요.
| 모델 / 양자화 | 필요 VRAM | 해당 GPU 예시 | 속도 |
|---|---|---|---|
| LLaMA 3 8B (FP16) | ~16GB | RTX 3080 Ti, RTX 4080 | 빠름 ⚡ |
| LLaMA 3 8B (Q4_K_M) | ~5GB | RTX 3060, RTX 4060 | 빠름 ⚡ |
| LLaMA 3 8B (Q8_0) | ~9GB | RTX 3070, RTX 4070 | 빠름 ⚡ |
| LLaMA 3 70B (Q4_K_M) | ~40GB | RTX 4090 x2, A100 | 보통 🔄 |
| LLaMA 3 8B (CPU 전용) | RAM 16GB+ | GPU 없어도 가능 | 느림 🐢 |
정확도가 약간 떨어지지만 메모리 사용량이 크게 줄어들어서 일반 소비자 GPU에서도 실행 가능해져요!
Q4_K_M이 속도와 품질의 밸런스가 가장 좋아서 많이 씀 👍
운영체제별 지원 현황
🍎 macOS (Apple Silicon) — M1/M2/M3 칩의 Metal GPU 가속 지원. 성능 굿!
🐧 Linux (Ubuntu 20.04+) — 가장 안정적이고 성능 최적화 최고. 서버 환경에 추천
🍎 macOS (Intel) — CPU 실행 가능하지만 느림. Metal 가속 미지원
특히 Apple Silicon Mac(M1/M2/M3)은 통합 메모리 구조라서 RAM이 GPU VRAM처럼 활용돼요.
M2 Pro 16GB 정도면 LLaMA 3 8B 양자화 버전 꽤 쾌적하게 돌아감 🍎
최소 / 권장 사양 정리
| 구분 | CPU | RAM | GPU | 저장공간 |
|---|---|---|---|---|
| 최소 (8B Q4) | Intel i5 / Ryzen 5 | 16GB | VRAM 6GB+ | SSD 20GB+ |
| 권장 (8B FP16) | Intel i7 / Ryzen 7 | 32GB | VRAM 16GB+ | SSD 50GB+ |
| 고사양 (70B Q4) | Intel i9 / Ryzen 9 | 64GB+ | VRAM 40GB+ | SSD 100GB+ |
"기다리는 재미"를 즐겨야 함ㅋㅋㅋ 그래도 테스트 목적이라면 충분히 써볼 만해요!
🚀 방법 1: ollama로 5분 만에 LLaMA 3 실행하기 (초강추!)
ollama는 진짜 미쳤어요ㅋㅋㅋ 설치하고 명령어 한 줄이면 LLaMA 3가 돌아가거든요.
입문자한테 제일 추천하는 방법이에요. 일단 이걸로 시작해봅시다!
Step 1: ollama 설치
https://ollama.com 접속 → 운영체제에 맞는 설치 파일 다운로드
Windows: .exe 설치 파일 / macOS: .dmg 파일 / Linux: 쉘 스크립트
curl -fsSL https://ollama.com/install.sh | sh
진짜 이게 끝임ㅋㅋㅋ 자동으로 CUDA/ROCm 감지해서 설치해줌
ollama --version
# 출력 예시: ollama version is 0.3.x
Step 2: LLaMA 3 모델 다운로드 및 실행
ollama run llama3
처음 실행하면 모델을 자동으로 다운로드해요. 약 4.7GB 정도 됨.다운로드 완료 후 바로 대화 가능! 🎉
ollama run llama3.1
ollama run llama3.1:70b
# Q4 양자화 (가장 가벼움)
ollama run llama3.1:8b-instruct-q4_K_M
# Q8 양자화 (품질 우선)
ollama run llama3.1:8b-instruct-q8_0
Step 3: ollama 주요 명령어 모음
# 설치된 모델 목록 확인
ollama list
# 모델 다운로드만 (실행 없이)
ollama pull llama3.1
# 모델 삭제
ollama rm llama3.1
# 실행 중인 모델 확인
ollama ps
# 모델 정보 확인
ollama show llama3.1
# 백그라운드 서버 시작 (API 서버)
ollama serve
Step 4: REST API로 활용하기
ollama는 기본적으로 http://localhost:11434에 REST API 서버를 열어줘요.
이걸 이용하면 Python, JavaScript 등 어떤 언어에서도 LLaMA 3를 호출할 수 있어요!
curl http://localhost:11434/api/generate -d '{
"model": "llama3.1",
"prompt": "안녕하세요! 파이썬으로 피보나치 수열 코드 짜줘",
"stream": false
}'
import requests
import json
def chat_with_llama(prompt):
url = "http://localhost:11434/api/generate"
data = {
"model": "llama3.1",
"prompt": prompt,
"stream": False
}
response = requests.post(url, json=data)
result = response.json()
return result["response"]
# 사용 예시
answer = chat_with_llama("파이썬으로 버블 정렬 알고리즘 구현해줘")
print(answer)
import requests
import json
def chat_stream(prompt):
url = "http://localhost:11434/api/generate"
data = {
"model": "llama3.1",
"prompt": prompt,
"stream": True # 스트리밍 활성화
}
with requests.post(url, json=data, stream=True) as response:
for line in response.iter_lines():
if line:
chunk = json.loads(line)
print(chunk["response"], end="", flush=True)
if chunk.get("done"):
break
chat_stream("머신러닝과 딥러닝의 차이를 설명해줘")
base_url="http://localhost:11434/v1"로 설정하면 됨 🔄
from openai import OpenAI
# ollama를 OpenAI API처럼 사용
client = OpenAI(
base_url="http://localhost:11434/v1",
api_key="ollama" # 아무 값이나 넣어도 됨
)
response = client.chat.completions.create(
model="llama3.1",
messages=[
{"role": "system", "content": "당신은 친절한 AI 어시스턴트입니다."},
{"role": "user", "content": "재능넷 같은 재능 공유 플랫폼을 만들려면 어떤 기술 스택이 필요해?"}
]
)
print(response.choices[0].message.content)
⚙️ 방법 2: llama.cpp로 직접 빌드해서 실행하기
llama.cpp는 C++로 작성된 초경량 LLM 추론 엔진이에요.
GPU 없이 CPU만으로도 꽤 쓸 만한 속도를 내는 게 특징이고, 메모리 효율이 극강이에요!
조금 복잡하지만 한 번 세팅해두면 진짜 강력함ㅋㅋ
사전 준비: 빌드 도구 설치
Windows의 경우:
# Visual Studio Build Tools 설치 (C++ 컴파일러)
# https://visualstudio.microsoft.com/downloads/ 에서 Build Tools 다운로드
# 또는 winget으로 설치
winget install Microsoft.VisualStudio.2022.BuildTools
# CMake 설치
winget install Kitware.CMake
# Git 설치
winget install Git.Git
Ubuntu/Debian Linux의 경우:
sudo apt update
sudo apt install -y build-essential cmake git libcurl4-openssl-dev
macOS의 경우:
# Xcode Command Line Tools 설치
xcode-select --install
# Homebrew로 cmake 설치
brew install cmake
llama.cpp 빌드 (공통)
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build
cmake --build build --config Release -j$(nproc)
# CUDA 버전 확인 먼저
nvcc --version
# CUDA 활성화해서 빌드
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)
# Metal은 기본으로 활성화됨 (macOS에서 자동)
cmake -B build -DGGML_METAL=ON
cmake --build build --config Release -j$(sysctl -n hw.logicalcpu)
GGUF 모델 파일 다운로드
llama.cpp는 GGUF 포맷의 모델 파일을 사용해요.
HuggingFace에서 다운로드할 수 있어요!
pip install huggingface_hub
# Meta-Llama-3-8B-Instruct Q4_K_M 버전 다운로드
# (bartowski가 양자화한 버전 - 품질 좋기로 유명)
huggingface-cli download \
bartowski/Meta-Llama-3-8B-Instruct-GGUF \
Meta-Llama-3-8B-Instruct-Q4_K_M.gguf \
--local-dir ./models
# 또는 wget으로 직접 다운로드
wget https://huggingface.co/bartowski/Meta-Llama-3-8B-Instruct-GGUF/resolve/main/Meta-Llama-3-8B-Instruct-Q4_K_M.gguf \
-O ./models/llama3-8b-q4.gguf
llama.cpp로 실행하기
# 대화형 모드로 실행
./build/bin/llama-cli \
-m ./models/llama3-8b-q4.gguf \
-p "당신은 친절한 AI 어시스턴트입니다." \
--ctx-size 4096 \
--n-predict 512 \
-i # 대화형 모드
# -ngl: GPU에 올릴 레이어 수 (높을수록 GPU 많이 사용)
# 8B 모델은 레이어가 32개, 전부 GPU에 올리려면 -ngl 32
./build/bin/llama-cli \
-m ./models/llama3-8b-q4.gguf \
-ngl 32 \
--ctx-size 8192 \
--n-predict 1024 \
-p "안녕! 오늘 날씨 어때?" \
-i
# HTTP 서버로 실행 (포트 8080)
./build/bin/llama-server \
-m ./models/llama3-8b-q4.gguf \
-ngl 32 \
--ctx-size 4096 \
--host 0.0.0.0 \
--port 8080
# 이제 http://localhost:8080 으로 웹 UI 접근 가능!
# API도 http://localhost:8080/v1/chat/completions 로 사용 가능
--threads 옵션으로 CPU 스레드 수 지정 (기본값은 자동)--batch-size로 배치 크기 조정 (기본 512, 메모리 여유 있으면 늘려도 됨)--mmap 옵션으로 메모리 맵 파일 사용 (대용량 모델에 유리)--flash-attn 옵션으로 Flash Attention 활성화 (속도 향상!)
🤗 방법 3: HuggingFace transformers로 파이썬에서 직접 실행
개발자라면 이 방법이 제일 강력해요!
파인튜닝, 커스텀 파이프라인, 다양한 라이브러리 연동 등 뭐든 할 수 있거든요.
단, 설치 과정이 좀 복잡하고 CUDA 환경 세팅이 필요해요 😅
Step 1: Python 환경 세팅
python --version
# Python 3.10.x 이상이어야 함
# venv 사용
python -m venv llama3-env
source llama3-env/bin/activate # Linux/macOS
# llama3-env\Scripts\activate # Windows
# 또는 conda 사용 (추천!)
conda create -n llama3 python=3.11
conda activate llama3
Step 2: CUDA 설치 (NVIDIA GPU 사용자)
NVIDIA GPU를 쓴다면 CUDA 툴킷 설치가 필수예요!
# GPU 드라이버 버전 확인
nvidia-smi
# 출력 예시:
# CUDA Version: 12.4 ← 이 버전에 맞는 PyTorch 설치해야 함
https://developer.nvidia.com/cuda-downloads 에서
운영체제, GPU 드라이버 버전에 맞는 CUDA 툴킷 설치
권장 버전: CUDA 12.1 또는 12.4
Step 3: PyTorch 설치
# CUDA 12.1 버전
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
# CUDA 12.4 버전
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124
# CPU 전용 (GPU 없는 경우)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
# macOS (Apple Silicon)
pip install torch torchvision torchaudio
import torch
print(f"PyTorch 버전: {torch.__version__}")
print(f"CUDA 사용 가능: {torch.cuda.is_available()}")
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:.1f} GB")
# Apple Silicon 확인
print(f"MPS 사용 가능: {torch.backends.mps.is_available()}")
Step 4: 필요 라이브러리 설치
pip install transformers>=4.40.0
pip install accelerate>=0.29.0
pip install bitsandbytes>=0.43.0 # 양자화 지원
pip install sentencepiece
pip install protobuf
pip install huggingface_hub
# 선택사항 (성능 향상)
pip install flash-attn --no-build-isolation # Flash Attention 2
pip install xformers # 메모리 효율 향상
Step 5: HuggingFace 계정 설정 및 모델 접근 권한
다운로드하려면 HuggingFace 계정으로 로그인하고 Meta의 이용 약관에 동의해야 해요!
https://huggingface.co 가입 →
Settings → Access Tokens → New token (Read 권한) 생성
https://huggingface.co/meta-llama/Meta-Llama-3-8B-Instruct 접속 →
"Request access" 버튼 클릭 → 이용 약관 동의 → 승인 대기 (보통 즉시~수 시간)
huggingface-cli login
# 토큰 입력 프롬프트가 뜨면 발급받은 토큰 입력
Step 6: LLaMA 3 실행 코드
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
# 모델 ID
model_id = "meta-llama/Meta-Llama-3-8B-Instruct"
# 토크나이저 로드
tokenizer = AutoTokenizer.from_pretrained(model_id)
# 모델 로드 (GPU 사용)
model = AutoModelForCausalLM.from_pretrained(
model_id,
torch_dtype=torch.bfloat16, # 메모리 절약
device_map="auto" # GPU 자동 할당
)
# 채팅 메시지 구성
messages = [
{"role": "system", "content": "당신은 친절하고 유능한 AI 어시스턴트입니다."},
{"role": "user", "content": "파이썬으로 간단한 웹 크롤러 만드는 방법 알려줘"},
]
# 입력 토큰화
input_ids = tokenizer.apply_chat_template(
messages,
add_generation_prompt=True,
return_tensors="pt"
).to(model.device)
# 텍스트 생성
with torch.no_grad():
outputs = model.generate(
input_ids,
max_new_tokens=512,
do_sample=True,
temperature=0.7,
top_p=0.9,
pad_token_id=tokenizer.eos_token_id
)
# 결과 디코딩
response = outputs[0][input_ids.shape[-1]:]
print(tokenizer.decode(response, skip_special_tokens=True))
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
model_id = "meta-llama/Meta-Llama-3-8B-Instruct"
# 4비트 양자화 설정
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_use_double_quant=True, # 이중 양자화로 추가 압축
bnb_4bit_quant_type="nf4" # NF4 양자화 타입
)
tokenizer = AutoTokenizer.from_pretrained(model_id)
# 4비트 양자화로 로드 (VRAM ~5GB로 줄어듦!)
model = AutoModelForCausalLM.from_pretrained(
model_id,
quantization_config=quantization_config,
device_map="auto"
)
print(f"모델 로드 완료! VRAM 사용량: {torch.cuda.memory_allocated()/1024**3:.2f} GB")
import torch
from transformers import pipeline
# 파이프라인 생성
pipe = pipeline(
"text-generation",
model="meta-llama/Meta-Llama-3-8B-Instruct",
model_kwargs={"torch_dtype": torch.bfloat16},
device_map="auto"
)
# 메시지 구성
messages = [
{"role": "system", "content": "당신은 유능한 개발자 어시스턴트입니다."},
{"role": "user", "content": "FastAPI로 REST API 만드는 기본 코드 보여줘"},
]
# 실행
outputs = pipe(
messages,
max_new_tokens=512,
do_sample=True,
temperature=0.7,
)
print(outputs[0]["generated_text"][-1]["content"])
device_map="auto"를 사용하면 모델을 GPU와 CPU에 자동으로 분산해서 올려줘요.VRAM이 부족하면 일부 레이어를 RAM에 올리는 방식으로 동작함.
물론 속도는 좀 느려지지만 실행 자체는 가능해짐!
🔧 CUDA 환경 세팅 완전 정복 (NVIDIA GPU 사용자 필독)
NVIDIA GPU를 쓴다면 CUDA 환경 세팅이 제대로 되어야 제 성능이 나와요.
이게 처음엔 좀 헷갈리는데, 한 번 정리해드릴게요!
CUDA 버전 호환성 매트릭스
| GPU 드라이버 버전 | 지원 CUDA 최대 버전 | 권장 PyTorch 버전 |
|---|---|---|
| ≥ 545.xx | CUDA 12.3 | PyTorch 2.2.x |
| ≥ 550.xx | CUDA 12.4 | PyTorch 2.3.x |
| ≥ 560.xx | CUDA 12.6 | PyTorch 2.4.x+ |
nvidia-smi에서 보이는 "CUDA Version"은 드라이버가 지원하는 최대 CUDA 버전이에요.실제로 설치된 CUDA 버전은
nvcc --version으로 확인해야 해요.PyTorch는 설치된 CUDA 버전에 맞춰서 설치해야 함!
Windows에서 CUDA 환경 세팅
https://www.nvidia.com/drivers 에서 최신 드라이버 다운로드 및 설치
# CUDA 경로 확인
$env:CUDA_PATH
# 출력: C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.4
# PATH에 CUDA bin 포함 확인
$env:PATH -split ";" | Where-Object { $_ -like "*CUDA*" }
# nvcc 버전 확인
nvcc --version
Linux에서 CUDA 환경 세팅
# Ubuntu에서 권장 드라이버 자동 설치
sudo ubuntu-drivers autoinstall
sudo reboot
# 또는 특정 버전 설치
sudo apt install nvidia-driver-550
# CUDA 저장소 추가
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt-get update
# CUDA 12.4 설치
sudo apt-get -y install cuda-toolkit-12-4
# 환경 변수 설정 (~/.bashrc에 추가)
echo 'export PATH=/usr/local/cuda-12.4/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda-12.4/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc
# 설치 확인
nvcc --version
nvidia-smi
ROCm (AMD GPU) 환경 세팅
AMD GPU 사용자도 포기하지 마세요! ROCm을 통해 LLaMA 3 실행 가능해요 🔴
# ROCm 저장소 추가
wget https://repo.radeon.com/amdgpu-install/6.1.3/ubuntu/jammy/amdgpu-install_6.1.60103-1_all.deb
sudo dpkg -i amdgpu-install_6.1.60103-1_all.deb
sudo apt update
# ROCm 설치
sudo amdgpu-install --usecase=rocm
# 사용자 그룹 추가
sudo usermod -a -G render,video $USER
sudo reboot
# PyTorch ROCm 버전 설치
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.1
# 확인
python -c "import torch; print(torch.cuda.is_available())" # ROCm도 cuda로 인식됨
🖥️ Open WebUI로 ChatGPT 같은 인터페이스 만들기
터미널에서 채팅하는 게 좀 불편하죠? ㅋㅋㅋ
Open WebUI를 사용하면 ChatGPT랑 똑같이 생긴 웹 인터페이스로 LLaMA 3를 쓸 수 있어요!
Docker로 설치 (가장 쉬운 방법)
https://docs.docker.com/get-docker/ 에서 운영체제에 맞게 설치
docker run -d \
-p 3000:8080 \
--gpus all \
-v ollama:/root/.ollama \
-v open-webui:/app/backend/data \
--name open-webui \
--restart always \
ghcr.io/open-webui/open-webui:ollama
docker run -d \
-p 3000:8080 \
-v ollama:/root/.ollama \
-v open-webui:/app/backend/data \
--name open-webui \
--restart always \
ghcr.io/open-webui/open-webui:ollama
docker run -d \
-p 3000:8080 \
--add-host=host.docker.internal:host-gateway \
-e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
-v open-webui:/app/backend/data \
--name open-webui \
--restart always \
ghcr.io/open-webui/open-webui:main
설치 완료 후 http://localhost:3000 접속하면 ChatGPT 같은 UI가 뜸!
처음 접속 시 관리자 계정 생성하고, 모델 선택해서 바로 대화 시작 가능 🎉
pip으로 설치 (Docker 없이)
# Open WebUI 설치
pip install open-webui
# 실행
open-webui serve
# 기본 포트 8080으로 실행됨
# http://localhost:8080 접속
⚡ 성능 최적화 꿀팁 모음
LLaMA 3 설치했는데 생각보다 느리다고요? 걱정 마세요!
몇 가지 설정만 바꿔도 속도가 확 올라가요 🚀
ollama 성능 최적화
# GPU 레이어 수 강제 지정 (기본값은 자동)
export OLLAMA_NUM_GPU=1
# 동시 처리 요청 수 (기본값 1)
export OLLAMA_NUM_PARALLEL=4
# 최대 로드된 모델 수 (기본값 1)
export OLLAMA_MAX_LOADED_MODELS=2
# 컨텍스트 윈도우 크기 (기본값 2048)
export OLLAMA_CONTEXT_LENGTH=8192
# Flash Attention 활성화
export OLLAMA_FLASH_ATTENTION=1
# 설정 후 ollama 재시작
ollama serve
# Modelfile 생성
cat > Modelfile << 'EOF'
FROM llama3.1
# 시스템 프롬프트 설정
SYSTEM """
당신은 전문적인 코딩 어시스턴트입니다.
항상 한국어로 답변하고, 코드에는 상세한 주석을 달아주세요.
"""
# 파라미터 설정
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER top_k 40
PARAMETER num_ctx 8192
PARAMETER num_predict 2048
EOF
# 커스텀 모델 생성
ollama create my-coder -f Modelfile
# 실행
ollama run my-coder
transformers 성능 최적화
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Meta-Llama-3-8B-Instruct",
torch_dtype=torch.bfloat16,
device_map="auto",
attn_implementation="flash_attention_2" # Flash Attention 2 활성화!
)
# Flash Attention 2는 긴 컨텍스트에서 특히 효과적
# 설치: pip install flash-attn --no-build-isolation
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Meta-Llama-3-8B-Instruct",
torch_dtype=torch.bfloat16,
device_map="auto"
)
# 모델 컴파일 (첫 실행은 느리지만 이후 빨라짐)
model = torch.compile(model, mode="reduce-overhead")
# 주의: torch.compile은 PyTorch 2.0+ 필요
# 첫 번째 추론 시 컴파일 시간이 걸림 (1~5분)
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct")
tokenizer.pad_token = tokenizer.eos_token # 패딩 토큰 설정
model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Meta-Llama-3-8B-Instruct",
torch_dtype=torch.bfloat16,
device_map="auto"
)
# 여러 프롬프트 동시 처리
prompts = [
"파이썬 리스트 컴프리헨션 설명해줘",
"SQL JOIN의 종류를 설명해줘",
"REST API와 GraphQL의 차이점은?"
]
inputs = tokenizer(
prompts,
return_tensors="pt",
padding=True,
truncation=True,
max_length=512
).to(model.device)
with torch.no_grad():
outputs = model.generate(
**inputs,
max_new_tokens=256,
do_sample=True,
temperature=0.7,
pad_token_id=tokenizer.eos_token_id
)
for i, output in enumerate(outputs):
response = tokenizer.decode(output, skip_special_tokens=True)
print(f"Q{i+1}: {prompts[i]}")
print(f"A{i+1}: {response}\n")
llama.cpp 성능 최적화 옵션
# 최적화된 실행 예시
./build/bin/llama-cli \
-m ./models/llama3-8b-q4.gguf \
-ngl 32 \ # GPU 레이어 수 (전체 GPU 활용)
--ctx-size 8192 \ # 컨텍스트 크기
--batch-size 512 \ # 배치 크기
--threads 8 \ # CPU 스레드 수 (CPU 코어 수에 맞게)
--flash-attn \ # Flash Attention 활성화
--mmap \ # 메모리 맵 파일 사용
--numa distribute \ # NUMA 최적화 (멀티 CPU 시스템)
-p "당신은 유능한 AI 어시스턴트입니다." \
-i
--verbose-prompt 옵션을 추가하면 토큰/초 속도를 확인할 수 있어요.RTX 4090 + LLaMA 3 8B Q4_K_M 기준으로 약 80~120 토큰/초 정도 나와요.
M2 Pro 16GB 기준으로는 약 30~50 토큰/초 정도!
🔥 자주 만나는 에러와 해결법
설치하다 보면 에러 한두 개는 꼭 만나게 됨ㅋㅋㅋ
자주 나오는 에러들 미리 정리해드릴게요!
에러 1: CUDA out of memory
torch.cuda.OutOfMemoryError: CUDA out of memory. Tried to allocate X GiB
해결 방법:
# 방법 1: 더 낮은 양자화 사용
model = AutoModelForCausalLM.from_pretrained(
model_id,
load_in_4bit=True, # 4비트 양자화
device_map="auto"
)
# 방법 2: GPU 캐시 비우기
import torch
torch.cuda.empty_cache()
# 방법 3: 배치 크기 줄이기
# max_new_tokens를 줄이거나 입력 길이 제한
# 방법 4: CPU 오프로드 활성화
model = AutoModelForCausalLM.from_pretrained(
model_id,
torch_dtype=torch.float16,
device_map="auto",
max_memory={0: "8GiB", "cpu": "16GiB"} # GPU/CPU 메모리 제한 설정
)
에러 2: ollama 모델 로드 실패
Error: model requires more system memory (X GiB) than is available (Y GiB)
# 더 작은 양자화 버전 사용
ollama run llama3.1:8b-instruct-q4_0 # Q4_0이 Q4_K_M보다 약간 작음
# 또는 더 작은 모델 사용
ollama run llama3.2:3b # 3B 파라미터 버전 (더 가벼움)
에러 3: CUDA not found / GPU 인식 안 됨
# CUDA 경로 확인
which nvcc
nvcc --version
# 환경 변수 재설정 (Linux)
export PATH=/usr/local/cuda/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH
# PyTorch CUDA 버전 확인
python -c "import torch; print(torch.version.cuda)"
# 드라이버와 CUDA 버전 불일치 시
# nvidia-smi로 드라이버 버전 확인 후
# 해당 드라이버가 지원하는 CUDA 버전으로 재설치
에러 4: HuggingFace 모델 다운로드 실패
# 토큰 재설정
huggingface-cli logout
huggingface-cli login
# 캐시 삭제 후 재시도
rm -rf ~/.cache/huggingface/hub/models--meta-llama*
# 오프라인 모드 비활성화
unset TRANSFORMERS_OFFLINE
unset HF_DATASETS_OFFLINE
# 프록시 설정 (방화벽 환경)
export HTTPS_PROXY=http://your-proxy:port
에러 5: bitsandbytes 설치 실패 (Windows)
# Windows용 bitsandbytes 설치
pip install bitsandbytes --prefer-binary --extra-index-url=https://jllllll.github.io/bitsandbytes-windows-webui
# 또는 conda 사용
conda install -c conda-forge bitsandbytes
에러 6: llama.cpp 빌드 실패
# cmake 버전 확인 (3.14 이상 필요)
cmake --version
# 빌드 디렉토리 초기화 후 재시도
rm -rf build
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j4 # 병렬 빌드 수 줄이기
# CUDA 경로 명시적 지정
cmake -B build \
-DGGML_CUDA=ON \
-DCUDA_TOOLKIT_ROOT_DIR=/usr/local/cuda-12.4
🎯 실전 활용 예시: 이런 것들을 만들 수 있어요!
LLaMA 3 로컬 환경 세팅이 완료됐다면, 이제 뭘 만들 수 있을까요?
재능넷 같은 플랫폼에서 AI 관련 재능을 거래하는 분들도 많은데,
이런 프로젝트들이 실제로 수요가 많아요 👀
예시 1: 로컬 AI 코딩 어시스턴트
import requests
import json
class LocalCodingAssistant:
def __init__(self, model="llama3.1", base_url="http://localhost:11434"):
self.model = model
self.base_url = base_url
self.history = []
self.system_prompt = """당신은 전문 소프트웨어 개발자 어시스턴트입니다.
코드 작성, 디버깅, 코드 리뷰를 도와줍니다.
항상 한국어로 설명하고, 코드에는 상세한 주석을 달아주세요."""
def chat(self, user_message):
self.history.append({
"role": "user",
"content": user_message
})
payload = {
"model": self.model,
"messages": [
{"role": "system", "content": self.system_prompt}
] + self.history,
"stream": False
}
response = requests.post(
f"{self.base_url}/api/chat",
json=payload
)
result = response.json()
assistant_message = result["message"]["content"]
self.history.append({
"role": "assistant",
"content": assistant_message
})
return assistant_message
def reset(self):
self.history = []
print("대화 기록이 초기화됐어요!")
# 사용 예시
assistant = LocalCodingAssistant()
print("🤖 로컬 AI 코딩 어시스턴트 시작!")
print("'종료'를 입력하면 끝납니다.\n")
while True:
user_input = input("👤 나: ")
if user_input.lower() in ["종료", "exit", "quit"]:
print("👋 안녕히 가세요!")
break
response = assistant.chat(user_input)
print(f"\n🤖 AI: {response}\n")
예시 2: 문서 요약 자동화 시스템
import requests
import json
from pathlib import Path
def summarize_document(file_path: str, max_length: int = 500) -> str:
"""텍스트 파일을 읽어서 LLaMA 3로 요약"""
# 파일 읽기
content = Path(file_path).read_text(encoding="utf-8")
# 너무 긴 경우 청크로 나누기
max_chars = 3000
if len(content) > max_chars:
content = content[:max_chars] + "..."
prompt = f"""다음 문서를 {max_length}자 이내로 핵심 내용만 요약해주세요.
문서 내용:
{content}
요약:"""
response = requests.post(
"http://localhost:11434/api/generate",
json={
"model": "llama3.1",
"prompt": prompt,
"stream": False,
"options": {
"temperature": 0.3, # 요약은 낮은 온도로
"num_predict": 600
}
}
)
return response.json()["response"]
# 사용 예시
summary = summarize_document("report.txt", max_length=300)
print("📄 요약 결과:")
print(summary)
예시 3: FastAPI로 로컬 AI API 서버 구축
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import requests
import json
from typing import Optional
app = FastAPI(title="로컬 LLaMA 3 API 서버")
class ChatRequest(BaseModel):
message: str
system_prompt: Optional[str] = "당신은 친절한 AI 어시스턴트입니다."
temperature: Optional[float] = 0.7
max_tokens: Optional[int] = 512
class ChatResponse(BaseModel):
response: str
model: str
tokens_used: int
OLLAMA_URL = "http://localhost:11434"
@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
try:
payload = {
"model": "llama3.1",
"messages": [
{"role": "system", "content": request.system_prompt},
{"role": "user", "content": request.message}
],
"stream": False,
"options": {
"temperature": request.temperature,
"num_predict": request.max_tokens
}
}
response = requests.post(
f"{OLLAMA_URL}/api/chat",
json=payload,
timeout=120
)
result = response.json()
return ChatResponse(
response=result["message"]["content"],
model=result["model"],
tokens_used=result.get("eval_count", 0)
)
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.get("/health")
async def health_check():
return {"status": "ok", "message": "로컬 LLaMA 3 API 서버 정상 작동 중!"}
# 실행: uvicorn main:app --host 0.0.0.0 --port 8000 --reload
AI/ML 관련 재능이 요즘 엄청 수요가 많거든요. 이 가이드로 실력 키워서 도전해보세요! 💪
📊 LLaMA 3.1 vs LLaMA 3.2 — 뭘 써야 해?
2024년 하반기에 LLaMA 3.2가 나왔어요!
버전별로 특징이 다르니까 용도에 맞게 선택하는 게 중요해요.
| 버전 | 모델 크기 | 특징 | 추천 용도 |
|---|---|---|---|
| LLaMA 3 (원본) | 8B, 70B | 기본 버전, 영어 중심 | 영어 텍스트 처리 |
| LLaMA 3.1 | 8B, 70B, 405B | 다국어 지원 강화, 긴 컨텍스트(128K), 도구 호출 | 다국어, 긴 문서, 에이전트 |
| LLaMA 3.2 | 1B, 3B, 11B, 90B | 멀티모달(이미지), 경량 모델 추가 | 모바일/엣지, 이미지 이해 |
한국어 성능 중요 → LLaMA 3.1 70B Q4 또는 한국어 파인튜닝 버전
이미지 이해 필요 → LLaMA 3.2 11B (Vision 모델)
초경량 엣지 배포 → LLaMA 3.2 1B 또는 3B
최고 성능 → LLaMA 3.1 405B (서버급 하드웨어 필요)
한국어 특화 LLaMA 파생 모델들
LLaMA 3 기반으로 한국어 파인튜닝된 모델들도 있어요!
한국어 성능이 중요하다면 이런 모델들을 고려해보세요:
LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct — LG AI 연구원의 한국어 특화 모델yanolja/EEVE-Korean-Instruct-10.8B-v1.0 — 야놀자 한국어 모델beomi/Llama-3-Open-Ko-8B — LLaMA 3 기반 한국어 파인튜닝MLP-KTLim/llama-3-Korean-Bllossom-8B — 한국어 Bllossom 모델
# EEVE 한국어 모델 (ollama 라이브러리에 있는 경우)
ollama run eeve-korean-10.8b
# 또는 HuggingFace에서 GGUF 버전 다운로드 후 ollama에 등록
# Modelfile 생성
cat > Modelfile << 'EOF'
FROM /path/to/korean-model.gguf
SYSTEM "당신은 한국어를 완벽하게 구사하는 AI 어시스턴트입니다."
PARAMETER temperature 0.7
PARAMETER num_ctx 4096
EOF
ollama create korean-llama -f Modelfile
ollama run korean-llama
🔐 보안 및 주의사항
로컬에서 LLM 돌릴 때 보안 관련해서 알아둬야 할 것들이 있어요!
API 서버 보안 설정
0.0.0.0으로 바인딩하면 같은 네트워크의 모든 기기에서 접근 가능해요.외부에 노출되면 누구나 여러분의 AI를 무료로 쓸 수 있게 됨ㅋㅋㅋ (좋은 건 아님)
개인 사용이라면
127.0.0.1(localhost)로만 바인딩하세요!
# 기본값은 이미 localhost만 허용
# 외부 접근 허용하려면 명시적으로 설정 필요
export OLLAMA_HOST=127.0.0.1:11434 # 로컬 전용 (기본값)
# export OLLAMA_HOST=0.0.0.0:11434 # 외부 접근 허용 (주의!)
ollama serve
from fastapi import FastAPI, HTTPException, Depends
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
import secrets
app = FastAPI()
security = HTTPBearer()
# 간단한 API 키 (실제 서비스에서는 더 안전하게 관리해야 함)
API_KEY = secrets.token_urlsafe(32)
print(f"API Key: {API_KEY}") # 처음 실행 시 키 출력
def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
if credentials.credentials != API_KEY:
raise HTTPException(status_code=401, detail="Invalid API key")
return credentials.credentials
@app.post("/chat")
async def chat(request: dict, token: str = Depends(verify_token)):
# 인증된 요청만 처리
pass
라이선스 주의사항
✅ 월간 활성 사용자 7억 명 미만 서비스에서 상업적 이용 가능
✅ 파인튜닝 및 파생 모델 생성 가능
❌ Meta의 경쟁 AI 제품 학습에 사용 불가
❌ "LLaMA" 또는 "Meta" 브랜드명을 서비스 이름에 사용 불가
❌ 불법적이거나 해로운 목적으로 사용 불가
전체 라이선스: https://llama.meta.com/llama3/license/
📝 전체 세팅 체크리스트
지금까지 배운 내용을 체크리스트로 정리해드릴게요!
□ RAM 확인 (최소 16GB, 권장 32GB+)
□ 저장공간 확인 (모델당 4~40GB)
□ 운영체제 확인 (Windows/macOS/Linux)
□ CUDA Toolkit 설치 (NVIDIA GPU 사용자)
□ ollama 설치 (입문자 추천)
□ 또는 llama.cpp 빌드 (CPU 최적화)
□ 또는 transformers 설치 (개발자용)
□ LLaMA 3 모델 접근 권한 신청
□ 적절한 양자화 버전 선택 (Q4_K_M 추천)
□ 모델 파일 다운로드
□ GPU 가속 확인
□ API 서버 실행 (선택)
□ WebUI 설치 (선택)
□ 성능 최적화 설정
LLaMA 3 로컬 실행 환경 세팅, 어떠셨나요?
처음엔 복잡해 보여도 ollama 하나만 설치하면 진짜 5분 만에 돌아가요ㅋㅋㅋ
일단 ollama로 시작해서 감 잡고, 나중에 llama.cpp나 transformers로 넘어가는 걸 추천해요!
AI/ML 개발 관련해서 더 배우고 싶다면 재능넷에서 관련 전문가들의 강의나 컨설팅도 찾아보세요.
로컬 LLM 세팅 대행, 파인튜닝 서비스, AI 앱 개발 등 다양한 재능들이 있답니다! 🎯
LLaMA 3 로컬 LLM ollama llama.cpp HuggingFace CUDA AI 개발 머신러닝
관련 키워드
댓글 작성
이 글에 대한 여러분의 생각을 들려주세요
로그인이 필요합니다
댓글을 작성하려면 먼저 로그인해주세요.
댓글 0
지식인의 숲 - 지적 재산권 보호 고지
지적 재산권 보호 고지
- 저작권 및 소유권: 본 컨텐츠는 재능넷의 독점 AI 기술로 생성되었으며, 대한민국 저작권법 및 국제 저작권 협약에 의해 보호됩니다.
- AI 생성 컨텐츠의 법적 지위: 본 AI 생성 컨텐츠는 재능넷의 지적 창작물로 인정되며, 관련 법규에 따라 저작권 보호를 받습니다.
- 사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
- 데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
- AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.
아직 댓글이 없습니다.