Ollama 모델 가이드

Ollama 모델 개요

Ollama는 다양한 오픈소스 LLM 모델을 로컬에서 실행할 수 있도록 지원합니다. 각 모델은 특정 용도와 하드웨어 환경에 최적화되어 있으며, 크기와 성능 사이의 트레이드오프를 고려해 선택해야 합니다.

주요 모델 패밀리

Ollama가 지원하는 주요 모델 패밀리는 다음과 같습니다:

모델 선택 프로세스

모델명:크기-양자화

# 예시
llama3.2:7b-instruct-q4_0
│       │   │         └─ 양자화 레벨 (4-bit)
│       │   └─────────── 튜닝 타입 (instruction)
│       └─────────────── 파라미터 크기 (7 billion)
└─────────────────────── 모델 패밀리 (Llama 3.2)

Llama 시리즈

Meta의 Llama (Large Language Model Meta AI)는 가장 인기 있는 오픈소스 LLM 패밀리입니다. Ollama에서 지원하는 Llama 모델은 다음과 같습니다.

Llama 3.2 (최신)

2024년 9월 출시된 Llama 3.2는 경량화와 멀티모달 기능에 초점을 맞춘 버전입니다.

설치 및 실행

# 기본 모델 다운로드 (7B)
ollama pull llama3.2

# 경량 모델 (1B)
ollama pull llama3.2:1b

# 비전 모델 (이미지 처리)
ollama pull llama3.2:11b-vision

# 실행
ollama run llama3.2
>>> 안녕하세요. 한국어로 답변해주세요.
안녕하세요! 네, 한국어로 답변드리겠습니다. 무엇을 도와드릴까요?

Llama 3.1

2024년 7월 출시된 Llama 3.1은 대규모 컨텍스트 윈도우(128K 토큰)를 지원하며, 최대 405B 파라미터 모델까지 제공합니다.

# Llama 3.1 8B 설치
ollama pull llama3.1:8b

# 특정 양자화 버전 선택
ollama pull llama3.1:8b-instruct-q4_0  # 4-bit 양자화
ollama pull llama3.1:8b-instruct-q8_0  # 8-bit 양자화 (고품질)

# 70B 모델 (강력한 GPU 필요)
ollama pull llama3.1:70b

Llama 3

2024년 4월 출시된 Llama 3는 뛰어난 성능과 안정성으로 여전히 많이 사용됩니다.

CodeLlama - 코딩 특화 모델

CodeLlama는 Llama 2를 코드 생성에 특화시킨 모델입니다. Python, JavaScript, C++, Java 등 다양한 언어를 지원하며, 특히 Python에서 뛰어난 성능을 보입니다.

CodeLlama 변형

실전 활용 예제

# CodeLlama 설치
ollama pull codellama:7b-instruct

# 코드 생성 예제
ollama run codellama:7b-instruct

>>> Write a Python function to calculate Fibonacci numbers with memoization

def fibonacci(n, memo={}):
    """
    Calculate the nth Fibonacci number using memoization.

    Args:
        n: The position in the Fibonacci sequence
        memo: Dictionary to store previously calculated values

    Returns:
        The nth Fibonacci number
    """
    if n in memo:
        return memo[n]

    if n <= 1:
        return n

    memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
    return memo[n]

# 사용 예시
for i in range(10):
    print(f"F({i}) = {fibonacci(i)}")

CodeLlama vs 일반 Llama

Mistral & Mixtral

Mistral AI의 모델들은 효율성과 성능의 균형이 뛰어나며, 프로덕션 환경에서 많이 사용됩니다.

Mistral 7B

Mistral 7B는 7B 파라미터임에도 불구하고 13B 모델과 비슷한 성능을 보이는 것으로 유명합니다.

# Mistral 7B 설치
ollama pull mistral

# Mistral 7B Instruct (대화 최적화)
ollama pull mistral:7b-instruct

# 실행
ollama run mistral:7b-instruct

Mixtral - Mixture of Experts

Mixtral은 MoE (Mixture of Experts) 아키텍처를 사용하여 큰 모델의 성능을 작은 메모리 풋프린트로 구현합니다.

# Mixtral 8x7B 설치
ollama pull mixtral

# Mixtral 8x22B (더 큰 모델)
ollama pull mixtral:8x22b

MoE 아키텍처 원리

Mistral vs Llama 비교

Phi - 소형 고성능 모델

Microsoft의 Phi 시리즈는 작은 크기로 큰 모델에 준하는 성능을 제공하는 것이 특징입니다.

Phi 모델 라인업

Phi 사용 예제

# Phi-3 mini 설치 (가장 작은 모델)
ollama pull phi3:mini

# Phi-3.5 설치 (최신 버전)
ollama pull phi3.5

# 실행
ollama run phi3:mini

>>> Explain quantum entanglement in simple terms

Quantum entanglement is like having two magic coins that are mysteriously
connected. When you flip one coin and it lands on heads, the other coin
instantly lands on tails, no matter how far apart they are. This connection
happens faster than light could travel between them, which puzzled Einstein
and led him to call it "spooky action at a distance."

Phi vs 다른 소형 모델 벤치마크

Gemma - Google의 경량 모델

Google의 Gemma는 Gemini 모델의 기술을 기반으로 개발된 오픈소스 모델입니다.

Gemma 모델

# Gemma 2B 설치 (가장 작음)
ollama pull gemma:2b

# Gemma 2 9B 설치 (권장)
ollama pull gemma2:9b

# 실행
ollama run gemma2:9b

Gemma의 주요 특징

• 안전성 강화: 유해 콘텐츠 필터링 내장
• 상업적 사용 가능: 제한 없는 라이선스
• 다국어 지원: 한국어 포함 다양한 언어
• 빠른 추론: 최적화된 추론 속도

Qwen - 다국어 강자

Alibaba의 Qwen (通义千问)은 특히 중국어와 다국어 처리에 강점을 보이는 모델입니다.

Qwen 모델 라인업

Qwen 실전 예제

# Qwen 2 7B 설치
ollama pull qwen2:7b

# 코딩 특화 버전
ollama pull qwen2.5-coder

# 다국어 테스트
ollama run qwen2:7b

>>> 请用中文和韩语解释机器学习

# 중국어 응답:
机器学习是人工智能的一个分支，它使计算机能够从数据中学习
并改进性能，而无需明确编程。

# 한국어 응답:
머신러닝은 인공지능의 한 분야로, 컴퓨터가 명시적인 프로그래밍
없이도 데이터로부터 학습하고 성능을 개선할 수 있게 합니다.

Qwen의 강점

• 다국어: 영어, 중국어, 한국어, 일본어 등 29개 언어 지원
• 긴 컨텍스트: 최대 32K 토큰 (Qwen2.5는 128K)
• 수학/코딩: GSM8K, HumanEval에서 높은 점수
• 효율성: 작은 모델도 우수한 성능

DeepSeek - 코딩 + 수학 전문가

DeepSeek은 특히 코딩과 수학 문제에 강한 성능을 보이는 중국 기반 모델입니다.

DeepSeek 모델

DeepSeek 코딩 예제

# DeepSeek Coder 설치
ollama pull deepseek-coder:6.7b

# 복잡한 알고리즘 구현
ollama run deepseek-coder:6.7b

>>> Implement a B-tree insertion algorithm in Python

class BTreeNode:
    def __init__(self, leaf=True):
        self.keys = []
        self.children = []
        self.leaf = leaf

class BTree:
    def __init__(self, t):
        self.root = BTreeNode()
        self.t = t  # Minimum degree

    def insert(self, key):
        root = self.root
        if len(root.keys) == (2 * self.t) - 1:
            # Root is full, split it
            new_root = BTreeNode(leaf=False)
            new_root.children.append(self.root)
            self._split_child(new_root, 0)
            self.root = new_root
        self._insert_non_full(self.root, key)

    def _split_child(self, parent, index):
        t = self.t
        full_child = parent.children[index]
        new_child = BTreeNode(leaf=full_child.leaf)

        # Split keys
        mid_key = full_child.keys[t - 1]
        new_child.keys = full_child.keys[t:(2 * t) - 1]
        full_child.keys = full_child.keys[0:t - 1]

        # Split children if not leaf
        if not full_child.leaf:
            new_child.children = full_child.children[t:2 * t]
            full_child.children = full_child.children[0:t]

        # Insert mid_key into parent
        parent.keys.insert(index, mid_key)
        parent.children.insert(index + 1, new_child)

    def _insert_non_full(self, node, key):
        i = len(node.keys) - 1

        if node.leaf:
            # Insert into leaf
            node.keys.append(None)
            while i >= 0 and key < node.keys[i]:
                node.keys[i + 1] = node.keys[i]
                i -= 1
            node.keys[i + 1] = key
        else:
            # Find child to insert into
            while i >= 0 and key < node.keys[i]:
                i -= 1
            i += 1

            if len(node.children[i].keys) == (2 * self.t) - 1:
                self._split_child(node, i)
                if key > node.keys[i]:
                    i += 1

            self._insert_non_full(node.children[i], key)

DeepSeek 벤치마크

특수 목적 모델

Ollama는 특정 작업에 특화된 다양한 모델도 지원합니다.

멀티모달 (비전) 모델

비전 모델 사용 예제

# LLaVA 설치
ollama pull llava

# 이미지와 함께 프롬프트 전송
ollama run llava "What's in this image?" /path/to/image.jpg

# API를 통한 이미지 분석
curl http://localhost:11434/api/generate -d '{
  "model": "llava",
  "prompt": "Describe this image in detail",
  "images": ["'$(base64 < image.jpg)'"]
}'

임베딩 모델

벡터 검색, RAG (Retrieval-Augmented Generation)에 사용되는 임베딩 모델들입니다.

임베딩 생성 예제

# 임베딩 모델 설치
ollama pull nomic-embed-text

# Python으로 임베딩 생성
import requests

def get_embedding(text):
    response = requests.post(
        'http://localhost:11434/api/embeddings',
        json={
            'model': 'nomic-embed-text',
            'prompt': text
        }
    )
    return response.json()['embedding']

# 사용 예시
text = "Ollama is a tool for running LLMs locally"
embedding = get_embedding(text)
print(f"Embedding dimension: {len(embedding)}")  # 768

기타 특화 모델

양자화 레벨 이해

양자화는 모델의 가중치를 낮은 정밀도로 변환하여 메모리 사용량과 추론 속도를 개선하는 기술입니다.

양자화 타입

양자화 비교 예제

# 다양한 양자화 버전 비교
# Llama 3.2 7B 기준

ollama pull llama3.2:7b-instruct-fp16    # ~14 GB
ollama pull llama3.2:7b-instruct-q8_0    # ~7.7 GB
ollama pull llama3.2:7b-instruct-q6_K    # ~5.9 GB
ollama pull llama3.2:7b-instruct-q5_K_M  # ~5.1 GB (권장)
ollama pull llama3.2:7b-instruct-q4_K_M  # ~4.4 GB
ollama pull llama3.2:7b-instruct-q4_0    # ~4.1 GB
ollama pull llama3.2:7b-instruct-q3_K_M  # ~3.2 GB
ollama pull llama3.2:7b-instruct-q2_K    # ~2.6 GB

양자화 명명 규칙 상세

# 양자화 타입 해석
q4_K_M
│ │ └─ M = Medium (중간 품질)
│ └─── K = K-quant 방식
└───── 4 = 4-bit 양자화

# 변형
q4_K_S  # S = Small (가장 빠름, 낮은 품질)
q4_K_M  # M = Medium (균형)
q4_K_L  # L = Large (높은 품질, 느림)

# 레거시 형식
q4_0    # 구식 4-bit 양자화
q4_1    # 개선된 4-bit (bias 추가)

용도별 모델 선택 가이드

작업 유형별 추천

하드웨어별 추천

8GB RAM (통합 그래픽)

• phi3:mini - 2.3 GB
• gemma:2b - 1.4 GB
• qwen2:1.5b - 1.0 GB
• llama3.2:3b - 2.0 GB

16GB RAM (일반 개발자 노트북)

• llama3.2:7b - 4.7 GB
• mistral:7b-instruct-q5_K_M - 4.1 GB
• codellama:7b - 3.8 GB
• qwen2:7b - 4.4 GB

32GB RAM (고성능 워크스테이션)

• llama3.1:70b-q4_0 - 23 GB
• mixtral:8x7b - 26 GB
• codellama:34b - 19 GB
• qwen2:72b-q4_0 - 28 GB

64GB+ RAM + 고성능 GPU

• llama3.1:70b - 40 GB
• mixtral:8x22b - 80 GB
• llama3.1:405b-q4_0 - 150 GB

언어별 추천

모델 태그 시스템

Ollama는 Docker와 유사한 태그 시스템을 사용합니다.

태그 예제

# 기본 형식
모델명:태그

# 태그 생략 시 :latest 자동 적용
ollama pull llama3.2
# = ollama pull llama3.2:latest

# 크기 지정
ollama pull llama3.2:7b
ollama pull llama3.2:3b
ollama pull llama3.2:1b

# 크기 + 튜닝 타입
ollama pull llama3.2:7b-instruct
ollama pull llama3.2:7b-text

# 크기 + 튜닝 + 양자화
ollama pull llama3.2:7b-instruct-q4_K_M
ollama pull llama3.2:7b-instruct-q8_0

# 특수 변형
ollama pull llama3.2:11b-vision
ollama pull codellama:7b-python

태그 구성 요소

태그 관리

# 설치된 모델 확인 (태그 포함)
ollama list

NAME                           ID              SIZE      MODIFIED
llama3.2:latest                abc123          4.7 GB    2 days ago
llama3.2:7b-instruct-q4_0      def456          4.1 GB    1 week ago
mistral:7b-instruct-v0.2       ghi789          4.1 GB    3 days ago

# 특정 태그 삭제
ollama rm llama3.2:7b-instruct-q4_0

# 모델 정보 확인
ollama show llama3.2:7b-instruct-q4_0

# 모든 버전 확인 (원격 레지스트리)
ollama search llama3.2

모델 비교 매트릭스

종합 비교

모델 비교는 용도(대화/코딩/다국어), 하드웨어 제약, 지연 시간 목표를 기준으로 판단하는 것이 가장 안전합니다.

객관적 벤치마크 점수

벤치마크 점수는 모델/버전/환경에 따라 크게 달라질 수 있습니다. 동일 조건에서 직접 테스트해 확인하세요.

모델 선택 모범 사례

평가 프로세스

1. 요구사항 정의
   • 주요 작업 유형 (대화, 코딩, 번역 등)
   • 응답 품질 vs 속도 우선순위
   • 다국어 지원 필요성
2. 하드웨어 확인
   • 사용 가능한 RAM/VRAM 크기
   • GPU 유무 및 성능
   • 저장 공간 (모델당 수 GB)
3. 후보 모델 선정
   • 3-5개 후보 모델 리스트업
   • 다양한 양자화 레벨 포함
4. 실전 테스트
   • 실제 사용 케이스로 테스트
   • 응답 품질, 속도, 메모리 사용량 측정
5. 최종 선택
   • 정량적 + 정성적 평가 결합
   • 프로덕션 환경 고려

간단한 테스트 스크립트

#!/bin/bash

# 여러 모델 성능 비교 스크립트

MODELS=("llama3.2:7b" "mistral:7b" "deepseek-coder:6.7b")
PROMPT="Write a Python function to find prime numbers"

for model in "${MODELS[@]}"; do
    echo "Testing $model..."

    # 시간 측정
    start=$(date +%s)

    # 응답 생성
    ollama run "$model" "$PROMPT" > "result_${model//:/_}.txt"

    end=$(date +%s)
    duration=$((end - start))

    echo "$model: ${duration}s" >> benchmark.txt

    # 메모리 사용량 확인
    ollama ps | grep "$model" >> benchmark.txt

    echo "---" >> benchmark.txt
done

echo "Benchmark complete. Check benchmark.txt for results."

핵심 정리

• Ollama 모델 가이드의 핵심 개념과 흐름을 정리합니다.
• Ollama 모델 개요를 단계별로 이해합니다.
• 실전 적용 시 기준과 주의점을 확인합니다.

실무 팁

• 입력/출력 예시를 고정해 재현성을 확보하세요.
• Ollama 모델 가이드 범위를 작게 잡고 단계적으로 확장하세요.
• Ollama 모델 개요 조건을 문서화해 대응 시간을 줄이세요.