<|begin_of_text|><|start_header_id|>system<|end_header_id|>

당신은 도움이 되는 AI 어시스턴트입니다.<|eot_id|><|start_header_id|>user<|end_header_id|>

안녕하세요! 파이썬으로 피보나치 수열을 구현해주세요.<|eot_id|><|start_header_id|>assistant<|end_header_id|>

<|begin_of_text|><|start_header_id|>system<|end_header_id|>

당신은 파이썬 전문가입니다. 간결하고 명확하게 답변하세요.<|eot_id|>
<|start_header_id|>user<|end_header_id|>

리스트 컴프리헨션이 뭔가요?<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>

리스트 컴프리헨션은 기존 리스트를 기반으로 새 리스트를 
간결하게 생성하는 파이썬 문법입니다.<|eot_id|>
<|start_header_id|>user<|end_header_id|>

예시 코드 보여주세요.<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct")

messages = [
    {"role": "system", "content": "당신은 도움이 되는 AI 어시스턴트입니다."},
    {"role": "user", "content": "파이썬으로 피보나치 수열을 구현해주세요."},
]

# 채팅 템플릿 자동 적용
input_text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True  # assistant 헤더 자동 추가
)

print(input_text)
# 출력:
# <|begin_of_text|><|start_header_id|>system<|end_header_id|>
# 당신은 도움이 되는 AI 어시스턴트입니다.<|eot_id|>
# <|start_header_id|>user<|end_header_id|>
# 파이썬으로 피보나치 수열을 구현해주세요.<|eot_id|>
# <|start_header_id|>assistant<|end_header_id|>

messages = [
    {
        "role": "system",
        "content": """당신은 감성 분석 전문가입니다.
주어진 텍스트의 감성을 분석하고 
'긍정', '부정', '중립' 중 하나로만 답하세요."""
    },
    {
        "role": "user",
        "content": "오늘 날씨가 너무 좋아서 기분이 최고야!"
    }
]
# 예상 출력: 긍정

messages = [
    {
        "role": "system",
        "content": "당신은 한국어 문장을 영어로 번역하는 전문가입니다."
    },
    {
        "role": "user",
        "content": "안녕하세요"
    },
    {
        "role": "assistant",
        "content": "Hello"
    },
    {
        "role": "user",
        "content": "감사합니다"
    },
    {
        "role": "assistant",
        "content": "Thank you"
    },
    {
        "role": "user",
        "content": "오늘 날씨가 정말 좋네요"  # 실제 번역할 문장
    }
]

messages = [
    {
        "role": "system",
        "content": """복잡한 문제를 풀 때 반드시 다음 형식으로 답하세요:
1단계: 문제 파악
2단계: 풀이 과정
3단계: 최종 답변

각 단계를 명확히 구분하여 설명하세요."""
    },
    {
        "role": "user",
        "content": """철수는 사과 5개를 가지고 있었습니다.
영희에게 2개를 주고, 마트에서 3개를 더 샀습니다.
그런데 집에 오다가 1개를 잃어버렸습니다.
철수에게 남은 사과는 몇 개인가요?"""
    }
]

# 필요 라이브러리 설치
# pip install transformers peft bitsandbytes trl accelerate datasets

import torch
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    TrainingArguments
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer
from datasets import load_dataset

# ===== 1. 모델 및 토크나이저 로드 =====
model_id = "meta-llama/Meta-Llama-3-8B-Instruct"

# 4비트 양자화 설정 (QLoRA)
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,  # 이중 양자화로 메모리 추가 절약
    bnb_4bit_quant_type="nf4",       # NormalFloat4 양자화
    bnb_4bit_compute_dtype=torch.bfloat16  # 계산은 bfloat16으로
)

# 모델 로드
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True
)

# 토크나이저 로드
tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"

# ===== 2. LoRA 설정 =====
lora_config = LoraConfig(
    r=16,                    # 랭크
    lora_alpha=32,           # 스케일링 팩터
    target_modules=[         # LLaMA 3에서 효과적인 타겟 모듈
        "q_proj",
        "k_proj", 
        "v_proj",
        "o_proj",
        "gate_proj",
        "up_proj",
        "down_proj"
    ],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

# kbit 학습을 위한 모델 준비
model = prepare_model_for_kbit_training(model)
model = get_peft_model(model, lora_config)

# 학습 가능한 파라미터 확인
model.print_trainable_parameters()
# 출력 예시: trainable params: 83,886,080 || all params: 8,114,589,696 
#            || trainable%: 1.0338

# ===== 3. 데이터셋 준비 =====
# 채팅 형식 데이터셋 예시
def format_chat_template(example):
    """데이터를 LLaMA 3 채팅 포맷으로 변환"""
    messages = [
        {"role": "system", "content": "당신은 도움이 되는 AI 어시스턴트입니다."},
        {"role": "user", "content": example["instruction"]},
        {"role": "assistant", "content": example["output"]}
    ]
    text = tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=False
    )
    return {"text": text}

# 데이터셋 로드 및 변환
dataset = load_dataset("your_dataset_name", split="train")
dataset = dataset.map(format_chat_template)

# ===== 4. 학습 설정 =====
training_args = TrainingArguments(
    output_dir="./llama3-finetuned",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,   # 실질적 배치 크기 = 2*4 = 8
    warmup_steps=100,
    learning_rate=2e-4,
    fp16=False,
    bf16=True,                        # bfloat16 사용 (A100, RTX 30/40 시리즈)
    logging_steps=10,
    save_strategy="epoch",
    evaluation_strategy="epoch",
    optim="paged_adamw_32bit",        # 메모리 효율적인 옵티마이저
    lr_scheduler_type="cosine",
    report_to="wandb"                 # W&B 로깅 (선택사항)
)

# ===== 5. SFT 트레이너 설정 및 학습 =====
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    dataset_text_field="text",
    tokenizer=tokenizer,
    max_seq_length=2048,
    packing=False
)

trainer.train()

# ===== 6. 모델 저장 =====
trainer.save_model("./llama3-finetuned-final")
tokenizer.save_pretrained("./llama3-finetuned-final")

# 데이터셋 형식 예시 (JSON Lines)
{
    "instruction": "파이썬으로 버블 정렬 알고리즘을 구현해주세요.",
    "input": "",  # 추가 컨텍스트 (없으면 빈 문자열)
    "output": "def bubble_sort(arr):\n    n = len(arr)\n    for i in range(n):\n        for j in range(0, n-i-1):\n            if arr[j] > arr[j+1]:\n                arr[j], arr[j+1] = arr[j+1], arr[j]\n    return arr"
}

# 멀티턴 대화 형식
{
    "conversations": [
        {"role": "system", "content": "당신은 파이썬 전문가입니다."},
        {"role": "user", "content": "리스트 정렬 방법을 알려주세요."},
        {"role": "assistant", "content": "파이썬에서 리스트를 정렬하는 방법은..."},
        {"role": "user", "content": "역순 정렬은요?"},
        {"role": "assistant", "content": "역순 정렬은 sorted(list, reverse=True)..."}
    ]
}

# Self-Instruct 데이터 증강 예시
# 기존 예시 데이터를 바탕으로 새로운 instruction-response 쌍 생성

augmentation_prompt = """
다음은 AI 어시스턴트 학습용 예시 데이터입니다:

예시 1:
질문: 파이썬에서 딕셔너리를 정렬하는 방법은?
답변: dict(sorted(d.items(), key=lambda x: x[1]))

예시 2:
질문: 리스트에서 중복을 제거하는 방법은?
답변: list(set(original_list))

위 예시들과 유사한 스타일로 파이썬 관련 질문-답변 쌍을 5개 더 생성해주세요.
각 쌍은 JSON 형식으로 출력하세요:
{"question": "...", "answer": "..."}
"""

# vLLM 설치
# pip install vllm

from vllm import LLM, SamplingParams

# LLaMA 3 모델 로드
llm = LLM(
    model="meta-llama/Meta-Llama-3-8B-Instruct",
    dtype="bfloat16",
    max_model_len=8192,
    gpu_memory_utilization=0.9  # GPU 메모리 90% 활용
)

# 샘플링 파라미터 설정
sampling_params = SamplingParams(
    temperature=0.7,      # 창의성 조절 (0=결정적, 1=창의적)
    top_p=0.9,            # nucleus sampling
    max_tokens=512,       # 최대 생성 토큰 수
    stop=["<|eot_id|>"]  # 생성 중단 토큰
)

# 배치 추론 (여러 프롬프트 동시 처리)
prompts = [
    "<|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n안녕하세요!<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n",
    "<|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n파이썬이란?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"
]

outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    print(output.outputs[0].text)

# llama-cpp-python 설치
# pip install llama-cpp-python

from llama_cpp import Llama

# GGUF 포맷 모델 로드 (Hugging Face에서 다운로드 가능)
llm = Llama(
    model_path="./Meta-Llama-3-8B-Instruct-Q4_K_M.gguf",
    n_ctx=8192,      # 컨텍스트 길이
    n_gpu_layers=35, # GPU 레이어 수 (0이면 CPU 전용)
    verbose=False
)

# 채팅 완성 API 사용
response = llm.create_chat_completion(
    messages=[
        {"role": "system", "content": "당신은 도움이 되는 AI입니다."},
        {"role": "user", "content": "안녕하세요!"}
    ],
    temperature=0.7,
    max_tokens=256
)

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

# RAG 구현 예시 (LangChain + LLaMA 3)
# pip install langchain langchain-community chromadb sentence-transformers

from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import TextLoader

# 1. 문서 로드 및 분할
loader = TextLoader("your_document.txt", encoding="utf-8")
documents = loader.load()

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)
chunks = text_splitter.split_documents(documents)

# 2. 임베딩 및 벡터 저장소 생성
embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
)
vectorstore = Chroma.from_documents(chunks, embeddings)

# 3. 검색 및 프롬프트 구성
def rag_query(question: str, k: int = 3) -> str:
    # 관련 문서 검색
    relevant_docs = vectorstore.similarity_search(question, k=k)
    context = "\n\n".join([doc.page_content for doc in relevant_docs])
    
    # RAG 프롬프트 구성
    messages = [
        {
            "role": "system",
            "content": f"""당신은 주어진 컨텍스트를 기반으로 질문에 답하는 AI입니다.
컨텍스트에 없는 내용은 "제공된 정보에서 찾을 수 없습니다"라고 답하세요.

[컨텍스트]
{context}"""
        },
        {
            "role": "user",
            "content": question
        }
    ]
    return messages

# LLaMA 3 Function Calling 예시
import json

# 사용 가능한 함수 정의
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "특정 도시의 현재 날씨를 가져옵니다",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "날씨를 조회할 도시 이름"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "온도 단위"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

# Function Calling 프롬프트 구성
system_prompt = f"""당신은 도움이 되는 AI 어시스턴트입니다.
다음 도구들을 사용할 수 있습니다:

{json.dumps(tools, ensure_ascii=False, indent=2)}

도구를 사용해야 할 때는 다음 형식으로 응답하세요:
{{"tool_call": {{"name": "함수명", "arguments": {{...}}}}}}"""

messages = [
    {"role": "system", "content": system_prompt},
    {"role": "user", "content": "서울의 현재 날씨가 어때요?"}
]

# DPO 학습 예시 (TRL 라이브러리 활용)
from trl import DPOTrainer, DPOConfig
from datasets import Dataset

# DPO 데이터셋 형식
# chosen: 더 좋은 응답, rejected: 더 나쁜 응답
dpo_data = {
    "prompt": [
        "파이썬에서 예외 처리를 어떻게 하나요?",
        # ... 더 많은 데이터
    ],
    "chosen": [
        "파이썬에서 예외 처리는 try-except 블록을 사용합니다:\n\ntry:\n    # 예외가 발생할 수 있는 코드\n    result = 10 / 0\nexcept ZeroDivisionError as e:\n    print(f'오류 발생: {e}')\nfinally:\n    print('항상 실행됩니다')",
        # ... 더 많은 데이터
    ],
    "rejected": [
        "예외 처리는 try except를 씁니다.",
        # ... 더 많은 데이터
    ]
}

dataset = Dataset.from_dict(dpo_data)

# DPO 설정
dpo_config = DPOConfig(
    beta=0.1,                    # KL 패널티 강도
    max_length=1024,
    max_prompt_length=512,
    output_dir="./llama3-dpo",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    learning_rate=5e-7,
    bf16=True
)

# DPO 트레이너
dpo_trainer = DPOTrainer(
    model=model,
    ref_model=None,  # None이면 자동으로 참조 모델 생성
    args=dpo_config,
    train_dataset=dataset,
    tokenizer=tokenizer
)

dpo_trainer.train()

# 코드 어시스턴트 System 프롬프트 예시
code_assistant_system = """당신은 Python 전문 코드 어시스턴트입니다.

코딩 원칙:
1. PEP 8 스타일 가이드를 엄격히 준수합니다
2. 타입 힌트를 반드시 사용합니다
3. docstring을 Google 스타일로 작성합니다
4. 예외 처리를 항상 포함합니다
5. 단위 테스트 코드도 함께 제공합니다

출력 형식:
- 코드 블록은 ```python으로 시작합니다
- 설명은 코드 위에 간략히 작성합니다
- 주의사항이 있으면 마지막에 ⚠️로 표시합니다"""

# 한국어 특화 파인튜닝을 위한 데이터 준비 팁
# 한국어 고품질 데이터셋 예시들:
# - KoAlpaca: 한국어 instruction 데이터셋
# - KLUE: 한국어 언어 이해 벤치마크
# - AIHub 데이터셋: 다양한 한국어 NLP 데이터

# 한국어 토크나이저 효율 확인
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct")

# LLaMA 3 vs LLaMA 2 한국어 토큰화 비교
text_ko = "안녕하세요, 저는 인공지능 개발자입니다."

tokens_llama3 = tokenizer.encode(text_ko)
print(f"LLaMA 3 토큰 수: {len(tokens_llama3)}")
# LLaMA 3: ~15개 토큰 (LLaMA 2 대비 약 40% 감소!)

# 한국어 특화 System 프롬프트
korean_system = """당신은 한국어를 모국어로 사용하는 AI 어시스턴트입니다.

언어 규칙:
- 항상 자연스러운 한국어로 답변합니다
- 존댓말을 기본으로 사용합니다
- 한국 문화와 정서를 이해하고 반영합니다
- 외래어는 한국어 표기법에 맞게 사용합니다
- 필요한 경우 영어 원문을 괄호 안에 병기합니다"""

# Unsloth로 LLaMA 3 파인튜닝 (2~5배 빠름!)
# pip install unsloth

from unsloth import FastLanguageModel
import torch

# 모델 로드 (Unsloth 최적화 버전)
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3-8B-Instruct",
    max_seq_length=2048,
    dtype=None,          # 자동 감지
    load_in_4bit=True,   # QLoRA
)

# LoRA 설정 (Unsloth 최적화)
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,      # Unsloth는 0 권장
    bias="none",
    use_gradient_checkpointing="unsloth",  # Unsloth 최적화
    random_state=42,
)

print("✅ Unsloth 모델 준비 완료! 기존 대비 2~5배 빠른 학습 가능")

# LLaMA 3.2 Vision 멀티모달 프롬프트 예시
from transformers import MllamaForConditionalGeneration, AutoProcessor
from PIL import Image
import requests

model_id = "meta-llama/Llama-3.2-11B-Vision-Instruct"

model = MllamaForConditionalGeneration.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
processor = AutoProcessor.from_pretrained(model_id)

# 이미지 + 텍스트 멀티모달 프롬프트
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},  # 이미지 플레이스홀더
            {"type": "text", "text": "이 이미지에서 무엇이 보이나요? 자세히 설명해주세요."}
        ]
    }
]

# 이미지 로드
image = Image.open("your_image.jpg")

# 입력 처리
input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(image, input_text, return_tensors="pt").to(model.device)

# 생성
output = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(output[0]))