# Llama 3 아키텍처 주요 특징
architecture_features = {
    "어휘 사전 크기": "128,256 토큰 (Llama 2의 4배)",
    "포지셔널 인코딩": "RoPE (Rotary Position Embedding)",
    "어텐션 메커니즘": "GQA (Grouped Query Attention)",
    "활성화 함수": "SwiGLU",
    "컨텍스트 윈도우": "8K (Llama 3) / 128K (Llama 3.1+)",
    "학습 데이터": "15T+ 토큰",
}

# Multi-Head Attention vs GQA 비교
mha_params = {
    "query_heads": 32,
    "key_heads": 32,     # 쿼리와 동일
    "value_heads": 32,   # 쿼리와 동일
}

gqa_params = {
    "query_heads": 32,
    "key_heads": 8,      # 그룹당 1개
    "value_heads": 8,    # 그룹당 1개
    "메모리 절약": "4배"
}

# HuggingFace를 통한 Llama 3 사용
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
import torch

model_id = "meta-llama/Meta-Llama-3-8B-Instruct"

# 4비트 양자화 (메모리 절약)
from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=quantization_config,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(model_id)

# 파이프라인 생성
text_generator = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
)

messages = [
    {"role": "system", "content": "You are a helpful AI assistant."},
    {"role": "user", "content": "머신러닝과 딥러닝의 차이점을 설명해주세요."},
]

output = text_generator(
    messages,
    max_new_tokens=512,
    do_sample=True,
    temperature=0.7,
    top_p=0.9,
)
print(output[0]['generated_text'][-1]['content'])

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "mistralai/Mistral-7B-Instruct-v0.3"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

# Mistral 인스트럭션 형식
messages = [
    {"role": "user", "content": "Python으로 퀵소트를 구현해주세요."}
]

text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)

model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

generated_ids = model.generate(
    **model_inputs,
    max_new_tokens=1024,
    do_sample=True,
    temperature=0.7
)

response = tokenizer.decode(generated_ids[0][len(model_inputs.input_ids[0]):], skip_special_tokens=True)
print(response)

# MoE 아키텍처 설명
moe_params = {
    "총 전문가 수": 8,
    "활성화되는 전문가": 2,
    "총 파라미터": "46.7B",
    "활성 파라미터": "12.9B",
    "추론 속도": "12.9B 모델과 유사",
    "성능": "70B 모델과 경쟁",
}

# MLA의 핵심 아이디어 (개념적 코드)
class MultiHeadLatentAttention:
    """
    기존 MHA: K, V 캐시가 토큰 수에 비례해 증가
    MLA: K, V를 저차원 잠재 벡터로 압축 저장
    - 메모리 사용량: 5~13배 감소
    - 성능: MHA와 동등
    """
    def __init__(self, hidden_dim=7168, num_heads=128, kv_lora_rank=512):
        self.hidden_dim = hidden_dim
        self.num_heads = num_heads
        self.kv_lora_rank = kv_lora_rank  # 압축된 KV 차원
        # 기존 KV 캐시: num_heads * head_dim * 2
        # MLA KV 캐시: kv_lora_rank (훨씬 작음)

# DeepSeek V3 API 사용 (OpenAI 호환)
from openai import OpenAI

client = OpenAI(
    api_key="<DEEPSEEK_API_KEY>",
    base_url="https://api.deepseek.com"
)

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "system", "content": "You are a helpful assistant"},
        {"role": "user", "content": "Python으로 이진 탐색 알고리즘을 구현해주세요."}
    ],
    stream=False
)

print(response.choices[0].message.content)

# DeepSeek R1 사용 예시
client = OpenAI(
    api_key="<DEEPSEEK_API_KEY>",
    base_url="https://api.deepseek.com"
)

# R1은 추론 모델이므로 reasoning_content 포함
response = client.chat.completions.create(
    model="deepseek-reasoner",
    messages=[
        {"role": "user", "content": "1부터 100까지 소수의 합을 구해주세요."}
    ]
)

# 추론 과정
reasoning = response.choices[0].message.reasoning_content
# 최종 답변
answer = response.choices[0].message.content

print("추론 과정 (요약):", reasoning[:200], "...")
print("최종 답변:", answer)

# Qwen2.5 사용 예시
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "Qwen/Qwen2.5-7B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

messages = [
    {"role": "system", "content": "You are Qwen, a helpful assistant."},
    {"role": "user", "content": "한국어로 인공지능 트렌드를 설명해주세요."}
]

text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)

model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

generated_ids = model.generate(
    **model_inputs,
    max_new_tokens=1024,
    temperature=0.7,
    top_p=0.8,
    repetition_penalty=1.05,
)

response_ids = [
    output_ids[len(input_ids):]
    for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
]

response = tokenizer.batch_decode(response_ids, skip_special_tokens=True)[0]
print(response)

from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
from qwen_vl_utils import process_vision_info
import torch

model = Qwen2VLForConditionalGeneration.from_pretrained(
    "Qwen/Qwen2-VL-7B-Instruct",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
processor = AutoProcessor.from_pretrained("Qwen/Qwen2-VL-7B-Instruct")

# 이미지 분석
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "https://example.com/chart.png"},
            {"type": "text", "text": "이 차트에서 보이는 트렌드를 한국어로 설명해주세요."},
        ],
    }
]

text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
image_inputs, video_inputs = process_vision_info(messages)

inputs = processor(
    text=[text],
    images=image_inputs,
    videos=video_inputs,
    return_tensors="pt",
).to(model.device)

generated_ids = model.generate(**inputs, max_new_tokens=512)
response = processor.batch_decode(
    [out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)],
    skip_special_tokens=True
)[0]
print(response)

# Gemma 2 사용
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-9b-it")
model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-2-9b-it",
    device_map="auto",
    torch_dtype=torch.bfloat16,
)

# Gemma 채팅 형식
chat = [
    {"role": "user", "content": "파이썬의 제너레이터와 이터레이터의 차이점을 설명해주세요."},
]

prompt = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
inputs = tokenizer.encode(prompt, add_special_tokens=False, return_tensors="pt")

outputs = model.generate(
    inputs.to(model.device),
    max_new_tokens=1024,
    do_sample=True,
    temperature=1,
    top_k=50,
    top_p=0.95,
)

response = tokenizer.decode(outputs[0][len(inputs[0]):], skip_special_tokens=True)
print(response)

# MediaPipe를 통한 온디바이스 실행 (개념)
# Google AI Edge SDK 사용

# Android/iOS에서 Gemma 실행
from mediapipe.tasks.python.genai import bundler, llm_inference

# 모델 번들링
bundler.bundle_model(
    model_path="gemma-2-2b-it-q4_k_m.gguf",
    tokenizer_path="tokenizer.model",
    start_token="<start_of_turn>",
    stop_tokens=["<end_of_turn>"],
    output_path="gemma_bundled.task",
)

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "microsoft/Phi-4"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto",
    torch_dtype=torch.bfloat16,
    trust_remote_code=True
)

messages = [
    {"role": "system", "content": "You are a helpful AI assistant."},
    {"role": "user", "content": "Explain quantum computing in simple terms."}
]

pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
)

output = pipe(messages, max_new_tokens=512, return_full_text=False)
print(output[0]['generated_text'])

학습 데이터 구성 (Phi-3-mini):
- "교과서 수준" 합성 데이터: 약 1T 토큰
- 교과서, 위키피디아, 코드: 고품질 필터링
- 크롤링 데이터: 품질 필터 통과한 것만 사용

"Less is More" 철학:
- 3.8B 파라미터로 7B 모델 성능 달성
- 데이터 효율: 3.3T 토큰으로 학습 (Llama 3의 1/4)

# macOS/Linux 설치
curl -fsSL https://ollama.com/install.sh | sh

# 모델 다운로드 및 실행
ollama run llama3.2

# 다른 모델 예시
ollama run mistral
ollama run qwen2.5:7b
ollama run deepseek-r1:8b
ollama run gemma2:9b

import ollama

# 간단한 채팅
response = ollama.chat(model='llama3.2', messages=[
    {
        'role': 'user',
        'content': '한국의 전통 음식을 5가지 알려주세요.',
    },
])
print(response['message']['content'])

import ollama

def stream_response(model: str, prompt: str):
    print(f"모델: {model}")
    print(f"프롬프트: {prompt}")
    print("응답: ", end="", flush=True)

    stream = ollama.chat(
        model=model,
        messages=[{'role': 'user', 'content': prompt}],
        stream=True,
    )

    full_response = ""
    for chunk in stream:
        text = chunk['message']['content']
        print(text, end='', flush=True)
        full_response += text

    print()
    return full_response

response = stream_response('mistral', '파이썬으로 피보나치 수열을 구현해주세요.')

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import ollama
import json

app = FastAPI()

@app.post("/chat")
async def chat(request: dict):
    model = request.get("model", "llama3.2")
    message = request.get("message", "")

    async def generate():
        stream = ollama.chat(
            model=model,
            messages=[{"role": "user", "content": message}],
            stream=True,
        )
        for chunk in stream:
            data = {
                "content": chunk["message"]["content"],
                "done": chunk.get("done", False)
            }
            yield f"data: {json.dumps(data, ensure_ascii=False)}\n\n"

    return StreamingResponse(generate(), media_type="text/event-stream")

@app.get("/models")
async def list_models():
    models = ollama.list()
    return {"models": [m["name"] for m in models["models"]]}

# 모델별 요구 메모리 (FP16 기준)
model_requirements = {
    "llama3.2:3b":    {"vram_gb": 2,  "speed": "매우 빠름",   "quality": "보통"},
    "llama3.2:8b":    {"vram_gb": 5,  "speed": "빠름",       "quality": "좋음"},
    "mistral:7b":     {"vram_gb": 5,  "speed": "빠름",       "quality": "좋음"},
    "qwen2.5:7b":     {"vram_gb": 5,  "speed": "빠름",       "quality": "좋음"},
    "gemma2:9b":      {"vram_gb": 6,  "speed": "보통",       "quality": "좋음"},
    "llama3.3:70b":   {"vram_gb": 40, "speed": "느림",       "quality": "매우 좋음"},
    "qwen2.5:72b":    {"vram_gb": 43, "speed": "느림",       "quality": "매우 좋음"},
    "deepseek-r1:8b": {"vram_gb": 5,  "speed": "보통",       "quality": "추론 특화"},
}

# 양자화 버전 (Q4 기준)
quantized_requirements = {
    "llama3.2:8b-q4":    {"vram_gb": 3,   "speed": "매우 빠름"},
    "llama3.3:70b-q4":   {"vram_gb": 20,  "speed": "보통"},
    "qwen2.5:72b-q4":    {"vram_gb": 22,  "speed": "보통"},
}

pip install vllm

from vllm import LLM, SamplingParams

# 모델 로드
llm = LLM(
    model="meta-llama/Meta-Llama-3-8B-Instruct",
    tensor_parallel_size=2,   # GPU 2개 사용
    gpu_memory_utilization=0.9,
    max_model_len=8192,
)

# 배치 추론
prompts = [
    "한국어 NLP의 특징을 설명해주세요.",
    "딥러닝과 머신러닝의 차이점은?",
    "트랜스포머 아키텍처란?",
]

sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=512,
)

outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    print(f"프롬프트: {output.prompt[:50]}...")
    print(f"응답: {output.outputs[0].text[:200]}")
    print()

# 서버 실행
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Meta-Llama-3-8B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2

# OpenAI 클라이언트로 vLLM 서버 사용
from openai import OpenAI

client = OpenAI(
    api_key="EMPTY",
    base_url="http://localhost:8000/v1"
)

response = client.chat.completions.create(
    model="meta-llama/Meta-Llama-3-8B-Instruct",
    messages=[{"role": "user", "content": "안녕하세요!"}],
    max_tokens=256,
)
print(response.choices[0].message.content)