콘텐츠 대표 이미지 - LLaMA 3 로컬 실행 완전 정복: 내 PC에서 AI를 직접 돌리는 환경 세팅 가이드
AI / 머신러닝 개발

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

☁️ 클라우드 없이, 요금 걱정 없이 — 내 컴퓨터에서 LLaMA 3를 직접 굴려보자!
설치부터 실행까지, 진짜 쓸 수 있는 실전 가이드 🔥

내 PC에서 LLaMA 3 돌리기 — 전체 흐름 ① 하드웨어 GPU / RAM 확인 ② 환경 설치 Python / CUDA / ollama ③ 모델 다운로드 HuggingFace / ollama ④ 실행 & 테스트 CLI / API / WebUI ⑤ 활용! 나만의 AI 최소 사양 RAM 16GB+, GPU 8GB+ 또는 CPU 전용 실행 가능 추천 도구 ollama, llama.cpp transformers, LM Studio 모델 크기 8B / 70B / 405B 양자화(Q4/Q8) 지원 운영체제 Windows / macOS / Linux 모두 지원! 🦙 LLaMA 3 — 오픈소스 AI의 새 시대, 지금 내 PC에서 시작! Meta AI 공개 모델 · 상업적 이용 가능(라이선스 확인 필수) · 완전 로컬 실행

🦙 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)하면 어느 정도 돌아가긴 하는데, 이건 뒤에서 자세히 설명할게요!

🙋 "근데 오픈소스면 완전 무료야? 상업적으로도 써도 돼?"
LLaMA 3는 Meta의 커뮤니티 라이선스 하에 배포돼요. 월간 활성 사용자 7억 명 미만의 서비스라면 상업적 이용도 가능! 단, Meta 브랜드 이름으로 서비스하거나 경쟁 AI 학습에 쓰는 건 안 됨. 라이선스 꼭 확인하세요 📋

💻 내 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 없어도 가능 느림 🐢
⚠️ 양자화(Quantization)란? 모델의 가중치를 32비트 또는 16비트 부동소수점에서 4비트, 8비트 등 더 낮은 정밀도로 압축하는 기술이에요.
정확도가 약간 떨어지지만 메모리 사용량이 크게 줄어들어서 일반 소비자 GPU에서도 실행 가능해져요!
Q4_K_M이 속도와 품질의 밸런스가 가장 좋아서 많이 씀 👍

운영체제별 지원 현황

🪟 Windows 10/11 — 완전 지원. CUDA, DirectML 모두 사용 가능
🍎 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+
💡 GPU 없어도 괜찮아요! llama.cpp는 CPU만으로도 실행 가능해요. 다만 토큰 생성 속도가 초당 1~5 토큰 정도로 느려서
"기다리는 재미"를 즐겨야 함ㅋㅋㅋ 그래도 테스트 목적이라면 충분히 써볼 만해요!

🛠️ LLaMA 3 로컬 실행 도구 비교 ollama ★★★★★ 설치 난이도: 쉬움 명령어 한 줄로 실행 REST API 내장 모델 자동 다운로드 Win/Mac/Linux 지원 GPU 자동 감지 추천 대상 입문자, 빠른 테스트 API 서버 구축 ⭐ 가장 추천! llama.cpp ★★★★☆ 설치 난이도: 보통 C++ 기반 초경량 CPU 최적화 최강 GGUF 포맷 지원 메모리 효율 최고 빌드 필요(cmake) 추천 대상 CPU 전용 환경 임베디드/서버 CPU 환경 최강 HuggingFace transformers ★★★☆☆ 설치 난이도: 어려움 Python 라이브러리 파인튜닝 가능 커스터마이징 최강 CUDA 필수 권장 의존성 복잡 추천 대상 ML 개발자 파인튜닝/연구 개발자용 최강 LM Studio ★★★★☆ 설치 난이도: 쉬움 GUI 인터페이스 모델 브라우저 내장 채팅 UI 제공 OpenAI API 호환 비상업적 무료 추천 대상 비개발자, 일반 사용자 GUI 선호자 GUI 환경 최강 이 가이드에서는 ollama + llama.cpp + transformers 세 가지를 모두 다룹니다!

🚀 방법 1: ollama로 5분 만에 LLaMA 3 실행하기 (초강추!)

ollama는 진짜 미쳤어요ㅋㅋㅋ 설치하고 명령어 한 줄이면 LLaMA 3가 돌아가거든요.
입문자한테 제일 추천하는 방법이에요. 일단 이걸로 시작해봅시다!

Step 1: ollama 설치

1
공식 사이트에서 다운로드
https://ollama.com 접속 → 운영체제에 맞는 설치 파일 다운로드
Windows: .exe 설치 파일 / macOS: .dmg 파일 / Linux: 쉘 스크립트
2
Linux 설치 (터미널 한 줄)
BASH
curl -fsSL https://ollama.com/install.sh | sh
진짜 이게 끝임ㅋㅋㅋ 자동으로 CUDA/ROCm 감지해서 설치해줌
3
설치 확인
BASH
ollama --version
# 출력 예시: ollama version is 0.3.x

Step 2: LLaMA 3 모델 다운로드 및 실행

1
LLaMA 3 8B 실행 (다운로드 + 실행 동시에!)
BASH
ollama run llama3
처음 실행하면 모델을 자동으로 다운로드해요. 약 4.7GB 정도 됨.
다운로드 완료 후 바로 대화 가능! 🎉
2
LLaMA 3.1 8B (최신 버전)
BASH
ollama run llama3.1
3
LLaMA 3.1 70B (고성능 버전, VRAM 많이 필요)
BASH
ollama run llama3.1:70b
4
특정 양자화 버전 선택
BASH
# Q4 양자화 (가장 가벼움)
ollama run llama3.1:8b-instruct-q4_K_M

# Q8 양자화 (품질 우선)
ollama run llama3.1:8b-instruct-q8_0

Step 3: ollama 주요 명령어 모음

BASH
# 설치된 모델 목록 확인
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를 호출할 수 있어요!

BASH (curl 예시)
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1",
  "prompt": "안녕하세요! 파이썬으로 피보나치 수열 코드 짜줘",
  "stream": false
}'
PYTHON
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)
PYTHON (스트리밍 방식)
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("머신러닝과 딥러닝의 차이를 설명해줘")
💡 OpenAI API 호환 모드! ollama는 OpenAI API 형식도 지원해요. 기존에 OpenAI API 쓰던 코드를 거의 수정 없이 ollama로 전환 가능!
base_url="http://localhost:11434/v1"로 설정하면 됨 🔄
PYTHON (OpenAI 호환 방식)
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의 경우:

PowerShell (관리자 권한)
# 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의 경우:

BASH
sudo apt update
sudo apt install -y build-essential cmake git libcurl4-openssl-dev

macOS의 경우:

BASH
# Xcode Command Line Tools 설치
xcode-select --install

# Homebrew로 cmake 설치
brew install cmake

llama.cpp 빌드 (공통)

1
소스코드 클론
BASH
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
2
CPU 전용 빌드 (기본)
BASH
cmake -B build
cmake --build build --config Release -j$(nproc)
3
NVIDIA GPU (CUDA) 빌드
BASH
# CUDA 버전 확인 먼저
nvcc --version

# CUDA 활성화해서 빌드
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)
4
Apple Silicon (Metal) 빌드
BASH
# Metal은 기본으로 활성화됨 (macOS에서 자동)
cmake -B build -DGGML_METAL=ON
cmake --build build --config Release -j$(sysctl -n hw.logicalcpu)

GGUF 모델 파일 다운로드

llama.cpp는 GGUF 포맷의 모델 파일을 사용해요.
HuggingFace에서 다운로드할 수 있어요!

1
huggingface-cli 설치
BASH
pip install huggingface_hub
2
LLaMA 3 GGUF 모델 다운로드
BASH
# 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로 실행하기

BASH (기본 실행)
# 대화형 모드로 실행
./build/bin/llama-cli \
  -m ./models/llama3-8b-q4.gguf \
  -p "당신은 친절한 AI 어시스턴트입니다." \
  --ctx-size 4096 \
  --n-predict 512 \
  -i  # 대화형 모드
BASH (GPU 레이어 지정)
# -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
BASH (서버 모드 - REST API)
# 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 로 사용 가능
💡 llama.cpp 성능 최적화 팁! --threads 옵션으로 CPU 스레드 수 지정 (기본값은 자동)
--batch-size로 배치 크기 조정 (기본 512, 메모리 여유 있으면 늘려도 됨)
--mmap 옵션으로 메모리 맵 파일 사용 (대용량 모델에 유리)
--flash-attn 옵션으로 Flash Attention 활성화 (속도 향상!)

🤗 방법 3: HuggingFace transformers로 파이썬에서 직접 실행

개발자라면 이 방법이 제일 강력해요!
파인튜닝, 커스텀 파이프라인, 다양한 라이브러리 연동 등 뭐든 할 수 있거든요.
단, 설치 과정이 좀 복잡하고 CUDA 환경 세팅이 필요해요 😅

Step 1: Python 환경 세팅

1
Python 3.10+ 설치 확인
BASH
python --version
# Python 3.10.x 이상이어야 함
2
가상환경 생성 (강력 권장!)
BASH
# 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 툴킷 설치가 필수예요!

1
CUDA 버전 확인
BASH
# GPU 드라이버 버전 확인
nvidia-smi

# 출력 예시:
# CUDA Version: 12.4  ← 이 버전에 맞는 PyTorch 설치해야 함
2
CUDA 툴킷 설치
https://developer.nvidia.com/cuda-downloads 에서
운영체제, GPU 드라이버 버전에 맞는 CUDA 툴킷 설치
권장 버전: CUDA 12.1 또는 12.4
3
cuDNN 설치 (선택사항이지만 권장)
https://developer.nvidia.com/cudnn 에서 다운로드
CUDA 버전에 맞는 cuDNN 설치

Step 3: PyTorch 설치

BASH (CUDA 12.1 기준)
# 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
PYTHON (설치 확인)
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: 필요 라이브러리 설치

BASH
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 계정 설정 및 모델 접근 권한

⚠️ 중요! Meta의 LLaMA 3 모델은 HuggingFace에서 게이트된(gated) 모델이에요.
다운로드하려면 HuggingFace 계정으로 로그인하고 Meta의 이용 약관에 동의해야 해요!
1
HuggingFace 계정 생성 및 토큰 발급
https://huggingface.co 가입 →
Settings → Access Tokens → New token (Read 권한) 생성
2
LLaMA 3 모델 접근 신청
https://huggingface.co/meta-llama/Meta-Llama-3-8B-Instruct 접속 →
"Request access" 버튼 클릭 → 이용 약관 동의 → 승인 대기 (보통 즉시~수 시간)
3
CLI로 로그인
BASH
huggingface-cli login
# 토큰 입력 프롬프트가 뜨면 발급받은 토큰 입력

Step 6: LLaMA 3 실행 코드

PYTHON (기본 실행)
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))
PYTHON (4비트 양자화 - VRAM 절약)
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")
PYTHON (파이프라인 방식 - 더 간단!)
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 환경 세팅

1
GPU 드라이버 최신 버전 설치
https://www.nvidia.com/drivers 에서 최신 드라이버 다운로드 및 설치
2
CUDA Toolkit 설치
https://developer.nvidia.com/cuda-downloads
Windows → x86_64 → exe(local) 선택해서 설치
3
환경 변수 확인
PowerShell
# 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 환경 세팅

1
NVIDIA 드라이버 설치
BASH
# Ubuntu에서 권장 드라이버 자동 설치
sudo ubuntu-drivers autoinstall
sudo reboot

# 또는 특정 버전 설치
sudo apt install nvidia-driver-550
2
CUDA Toolkit 설치 (Ubuntu 22.04 + CUDA 12.4 예시)
BASH
# 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 실행 가능해요 🔴

BASH (Ubuntu + ROCm)
# 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로 설치 (가장 쉬운 방법)

1
Docker 설치
https://docs.docker.com/get-docker/ 에서 운영체제에 맞게 설치
2
ollama + Open WebUI 한 번에 실행
BASH (GPU 사용)
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
3
CPU 전용 실행
BASH
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
4
기존 ollama와 연결 (ollama가 이미 설치된 경우)
BASH
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 없이)

BASH
# Open WebUI 설치
pip install open-webui

# 실행
open-webui serve

# 기본 포트 8080으로 실행됨
# http://localhost:8080 접속

⚡ 성능 최적화 꿀팁 모음

LLaMA 3 설치했는데 생각보다 느리다고요? 걱정 마세요!
몇 가지 설정만 바꿔도 속도가 확 올라가요 🚀

ollama 성능 최적화

BASH (환경 변수 설정)
# 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
BASH (Modelfile로 커스텀 모델 설정)
# 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 성능 최적화

PYTHON (Flash Attention 2 활성화)
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
PYTHON (torch.compile로 추론 가속)
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분)
PYTHON (배치 처리로 처리량 향상)
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 성능 최적화 옵션

BASH
# 최적화된 실행 예시
./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
💡 속도 벤치마크 팁! llama.cpp에서 --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

해결 방법:

PYTHON
# 방법 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)
BASH
# 더 작은 양자화 버전 사용
ollama run llama3.1:8b-instruct-q4_0  # Q4_0이 Q4_K_M보다 약간 작음

# 또는 더 작은 모델 사용
ollama run llama3.2:3b  # 3B 파라미터 버전 (더 가벼움)

에러 3: CUDA not found / GPU 인식 안 됨

BASH
# 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 모델 다운로드 실패

BASH
# 토큰 재설정
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)

BASH
# 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 빌드 실패

BASH
# 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 코딩 어시스턴트

PYTHON
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: 문서 요약 자동화 시스템

PYTHON
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 서버 구축

PYTHON
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 환경 세팅 대행, 커스텀 AI 챗봇 개발, LLM 파인튜닝 서비스 등
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 8B (가성비 최고)
한국어 성능 중요 → LLaMA 3.1 70B Q4 또는 한국어 파인튜닝 버전
이미지 이해 필요 → LLaMA 3.2 11B (Vision 모델)
초경량 엣지 배포 → LLaMA 3.2 1B 또는 3B
최고 성능 → LLaMA 3.1 405B (서버급 하드웨어 필요)

한국어 특화 LLaMA 파생 모델들

LLaMA 3 기반으로 한국어 파인튜닝된 모델들도 있어요!
한국어 성능이 중요하다면 이런 모델들을 고려해보세요:

🇰🇷 한국어 특화 모델 (HuggingFace에서 검색 가능): 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 모델
BASH (ollama로 한국어 모델 실행)
# 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 서버 보안 설정

⚠️ 주의! ollama나 llama.cpp 서버를 0.0.0.0으로 바인딩하면 같은 네트워크의 모든 기기에서 접근 가능해요.
외부에 노출되면 누구나 여러분의 AI를 무료로 쓸 수 있게 됨ㅋㅋㅋ (좋은 건 아님)
개인 사용이라면 127.0.0.1(localhost)로만 바인딩하세요!
BASH (ollama 로컬 전용 설정)
# 기본값은 이미 localhost만 허용
# 외부 접근 허용하려면 명시적으로 설정 필요
export OLLAMA_HOST=127.0.0.1:11434  # 로컬 전용 (기본값)
# export OLLAMA_HOST=0.0.0.0:11434  # 외부 접근 허용 (주의!)

ollama serve
PYTHON (API 키 인증 추가)
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

라이선스 주의사항

📋 LLaMA 3 라이선스 핵심 요약: ✅ 연구 및 개발 목적 사용 가능
✅ 월간 활성 사용자 7억 명 미만 서비스에서 상업적 이용 가능
✅ 파인튜닝 및 파생 모델 생성 가능
❌ Meta의 경쟁 AI 제품 학습에 사용 불가
❌ "LLaMA" 또는 "Meta" 브랜드명을 서비스 이름에 사용 불가
❌ 불법적이거나 해로운 목적으로 사용 불가

전체 라이선스: https://llama.meta.com/llama3/license/

📝 전체 세팅 체크리스트

지금까지 배운 내용을 체크리스트로 정리해드릴게요!

🔲 하드웨어 확인 □ GPU VRAM 확인 (8B 모델: 최소 6GB, 권장 8GB+)
□ RAM 확인 (최소 16GB, 권장 32GB+)
□ 저장공간 확인 (모델당 4~40GB)
□ 운영체제 확인 (Windows/macOS/Linux)
🔲 소프트웨어 설치 □ Python 3.10+ 설치
□ CUDA Toolkit 설치 (NVIDIA GPU 사용자)
□ ollama 설치 (입문자 추천)
□ 또는 llama.cpp 빌드 (CPU 최적화)
□ 또는 transformers 설치 (개발자용)
🔲 모델 다운로드 □ HuggingFace 계정 생성 및 토큰 발급
□ LLaMA 3 모델 접근 권한 신청
□ 적절한 양자화 버전 선택 (Q4_K_M 추천)
□ 모델 파일 다운로드
🔲 실행 및 테스트 □ 기본 실행 테스트
□ GPU 가속 확인
□ API 서버 실행 (선택)
□ WebUI 설치 (선택)
□ 성능 최적화 설정
🦙 LLaMA 3 로컬 실행 완료! 이제 내 PC에서 AI가 돌아가고 있어요 🔒 완전한 프라이버시 내 데이터는 내 PC 안에만 외부 서버 전송 없음 오프라인 환경에서도 OK 💸 비용 제로 API 요금 걱정 없음 무제한 사용 가능 전기세만 내면 됨ㅋㅋ 🛠️ 완전한 커스터마이징 파인튜닝 자유롭게 시스템 프롬프트 마음대로 나만의 AI 서비스 구축 🚀 이제 당신만의 로컬 AI 환경이 완성됐습니다!
🦙 🚀 💻 🔥 ⚡

LLaMA 3 로컬 실행 환경 세팅, 어떠셨나요?

처음엔 복잡해 보여도 ollama 하나만 설치하면 진짜 5분 만에 돌아가요ㅋㅋㅋ
일단 ollama로 시작해서 감 잡고, 나중에 llama.cpp나 transformers로 넘어가는 걸 추천해요!

AI/ML 개발 관련해서 더 배우고 싶다면 재능넷에서 관련 전문가들의 강의나 컨설팅도 찾아보세요.
로컬 LLM 세팅 대행, 파인튜닝 서비스, AI 앱 개발 등 다양한 재능들이 있답니다! 🎯

LLaMA 3 로컬 LLM ollama llama.cpp HuggingFace CUDA AI 개발 머신러닝

댓글 작성

이 글에 대한 여러분의 생각을 들려주세요

댓글 0
댓글을 불러오는 중입니다.

아직 댓글이 없습니다.