[플레이데이터 SK네트웍스 Family AI 캠프 12기] 12주차 회고

매일 똑같은 코딩 자세

 

🗓️기간

12주차 : 2025.05.12~2025.05.16 ( 5월 3주 )

 

#. 한 주를 보내며...

  4주간 이어져 온 LLM 교육의 가장 최신 트렌드까지 배우는 한주였다. 교재의 RAG V1을 포함하여 최신 트렌드인 RAG V2 (RAG++)를 배울 수 있었다. 수업내용이 빠른듯해도 짧은 시간에 교재내용을 모두 배우고 최신트렌드 까지 배우기엔 오히려  짧다고 느껴졌다. 매일매일 새로운 트렌드의 기술을 배우며 다음프로젝트와 파이널 프로젝트를 계획해 볼 수 있었고, 캠프 이후의 내 계획에 대해서도 생각해 볼 수 있었다.

1. 좋았던 점

  RAG V2 라는 최근 트렌드를 배운다는게 매우 좋았다. 교재의 RAG V1 내용도 전부 진행하고 최근 트렌드인 V2로 넘어가니 RAG시스템에서 느껴졌던 많은 단점들이 보완되고, 왜 RAG를 쓸까라는 의문이 많이 해소될 수 있었다. 단순 Vector DB + LLM은 최근의 LLM의 거대화와 높은 성장으로 불필요한 단계라고 느껴졌지만, V2를 배우니 LLM의 근본적인 문제를 해결할 수 있고, 적은 리소스로 높은 수준의 모델을 구축할 수 있다는게 매우 좋았다.

  단계별 상급 추론을 바탕으로 한 프롬프트 엔지니어링은 기존의 단순한 프롬프트 엔지니어링을 복잡하고 완성도 높은 프롬프트 엔지니어링으로 바꾸어, 간단한 작업으로도 LLM의 답변 능력을 높은 수준으로 끌어올릴 수 있었다.

2. 개선점

  LLM의 작동방식을 더 자세하게 이해하고, 추론과 답변을 유도하는 설계를 정밀화 했다. 기존에는 LLM을 단순하게 추론-답변 이라고만 생각했지만, 이번주 교육을 받은 뒤에는 LLM의 구성을 생각하면서 추론형 프롬프트를 제작하여 LLM의 추론능력과 답변방식을 전문화,규격화 시킬수 있었다.

 아는만큼 보인다고 이전에는 알지 못했으나, 정확하게 배우고 나니 미세한 차이로 인한 높은 결과치에 대해서 알 수 있었다. 이전에는 답의 균일화를 만드는 방식을 파인튜닝이나 높은 리소스,많은 비용으로만 작업하는방식을 생각했으나 교육 후 기본원리를 바탕으로 미세조정만으로도 높은 리소스와 많은 비용에 맞먹는 효과를 볼 수있는 기술을 익일 수있었다.

3. 학습내용 및 예제 

1) RAG 기반 LangChain 시스템 / 파이프라인

  - 임베딩 모델 : ko-sroberta-multitask

  - Vector DB : FAISS / Chroma DB

  - LLM : HyperCLOVAX

 

# ============================
# 필수 라이브러리 설치
# ============================

# 벡터 DB (FAISS, Chroma), LangChain, HuggingFace 관련 패키지 설치
!pip install faiss-cpu chromadb langchain-huggingface langchain_chroma -q

# GPU 사용 여부에 따라 설치
!pip install torch -q

# ============================
# 데이터 준비
# ============================

# 샘플 문서 데이터 (한글 뉴스 기사)
from langchain.schema import Document

# 한글 뉴스 기사 샘플 데이터 (5개)
documents = [
    "서울아산병원에서 심혈관질환 환자를 위한 새 운동 프로그램이 발표되었다.",
    "강남구는 청소년을 위한 체력 증진 프로그램을 시작했다.",
    "미국과 중국이 경제 회담에서 관세 조정 합의를 도출했다.",
    "일본은 오사카 엑스포에서 AI 기술을 공개했다.",
    "대전 서구가 허위 광고 단속을 강화했다."
]

# LangChain의 Document 객체로 변환
docs = [Document(page_content=doc) for doc in documents]

# ============================
# 임베딩 모델 설정
# ============================

# HuggingFace에서 한국어 임베딩 모델 로드
from langchain_huggingface import HuggingFaceEmbeddings

# 모델명: 'jhgan/ko-sroberta-multitask' (한국어 지원 모델)
embedding_model = HuggingFaceEmbeddings(model_name='jhgan/ko-sroberta-multitask')

# ============================
# FAISS 벡터 DB 생성
# ============================

import faiss
from langchain.vectorstores import FAISS

# FAISS 벡터 DB 생성
# - from_documents(): 문서 리스트와 임베딩 모델을 받아서 벡터 DB 생성
faiss_vectorstore = FAISS.from_documents(docs, embedding_model)

# FAISS 리트리버 생성 (검색 결과 상위 2개 반환)
faiss_retriever = faiss_vectorstore.as_retriever(search_kwargs={'k': 2})

# ============================
# Chroma 벡터 DB 생성
# ============================

import chromadb
from langchain_chroma import Chroma

# Chroma 클라이언트 초기화
chroma_client = chromadb.Client()

# Chroma 벡터 DB 생성
chroma_vectorstore = Chroma(
    collection_name="news_collection",
    embedding_function=embedding_model,
    client=chroma_client
)

# Chroma 리트리버 생성 (검색 결과 상위 2개 반환)
chroma_retriever = chroma_vectorstore.as_retriever(search_kwargs={'k': 2})

# ============================
# LLM 파이프라인 생성
# ============================

from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
from langchain_huggingface import HuggingFacePipeline

# 네이버 하이퍼클로바X 모델 설정
model_id = 'naver-hyperclovax/HyperCLOVAX-SEED-Text-Instruct-1.5B'

# 모델 및 토크나이저 로드
model = AutoModelForCausalLM.from_pretrained(model_id)
tokenizer = AutoTokenizer.from_pretrained(model_id)

# LLM 파이프라인 설정
text_generation_pipeline = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    max_new_tokens=300,   # 최대 출력 토큰 수
    device='cuda' if torch.cuda.is_available() else 'cpu',
    do_sample=True,       # 창의적 생성 여부
    temperature=0.6,      # 무작위성 조절 (높을수록 창의적)
    top_p=0.9             # 상위 90%의 확률 내에서 샘플링
)

# LangChain 통합
llm = HuggingFacePipeline(pipeline=text_generation_pipeline)

# ============================
# RAG 파이프라인 - LangChain 기반
# ============================

from langchain.prompts import PromptTemplate
from langchain.chains import RetrievalQA

# RAG 프롬프트 템플릿 (요약 요청)
prompt_template = """
다음 문서를 요약해 주세요:
{context}

질문: {question}
"""
# LangChain의 PromptTemplate 객체 생성
prompt = PromptTemplate(template=prompt_template, input_variables=['context', 'question'])

# FAISS 기반 RAG 파이프라인 생성
faiss_qa = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type='stuff',    # stuff: 모든 문서를 합쳐서 처리
    retriever=faiss_retriever,
    return_source_documents=True,
    chain_type_kwargs={'prompt': prompt}
)

# Chroma 기반 RAG 파이프라인 생성
chroma_qa = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type='stuff',
    retriever=chroma_retriever,
    return_source_documents=True,
    chain_type_kwargs={'prompt': prompt}
)

# ============================
# 쿼리 및 결과 확인
# ============================

# 사용자 쿼리
query = "심혈관 질환 관련 내용을 요약해 주세요."

# FAISS DB에서 검색 및 요약
faiss_result = faiss_qa.invoke({'query': query})
print("FAISS 결과:\n", faiss_result['result'])

# 검색된 문서 출력
print("FAISS 참조 문서:")
for doc in faiss_result['source_documents']:
    print(doc.page_content)

# Chroma DB에서 검색 및 요약
chroma_result = chroma_qa.invoke({'query': query})
print("\n Chroma 결과:\n", chroma_result['result'])

# 검색된 문서 출력
print("Chroma 참조 문서:")
for doc in chroma_result['source_documents']:
    print(doc.page_content)

 

2) Step-by-Step Reasoning & CoT

 

# ============================================
# 환경설정 및 라이브러리 임포트
# ============================================

# Pydantic: 데이터 검증을 위한 모델링 라이브러리
from pydantic import BaseModel, Field
from typing import Dict, Optional, Any, List

# LangChain: LLM(대형 언어 모델)과의 통합 프레임워크
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

# JSON 파싱 및 검증
import json

# ============================================
# 데이터 구조 정의
# ============================================

# 과일 단가 데이터
FRUIT_PRICE = {
    "사과": {"단가": 1750},
    "오렌지": {"단가": 1600},
    "바나나": {"단가": 750},
}

# 재고 데이터
FRUIT_STOCK = {
    "사과": 10,
    "오렌지": 8,
    "바나나": 15
}

# 할인 기준 및 할인율
DISCOUNT_THREASHOLD = 10000  # 10,000원 이상 시 할인 적용
DISCOUNT_RATE = 0.1  # 10% 할인

# ============================================
# OpenAI API 설정
# ============================================

# OpenAI API Key
open_ai_key = 'my_Key'

# GPT-4 모델 초기화
llm = ChatOpenAI(
    model="gpt-4o",
    temperature=0.1,
    api_key=open_ai_key
)

# ============================================
# Pydantic 모델 정의
# ============================================

# 사용자 요청 데이터 구조
class PurchaseRequest(BaseModel):
    request_type: str = Field(..., description='요청 타입 (비용계산, 단가비교, 과일추천, 재고상태)')
    items: Optional[Dict[str, int]] = Field(None, description='과일 이름과 수량')
    budget: Optional[int] = Field(None, description='예산 (원 단위)')
    compare_item: Optional[List[str]] = Field(None, description='비교할 과일 리스트')

# JSON 응답 모델 - 비용 계산
class CalculationResponse(BaseModel):
    total_cost: Optional[float]
    currency: Optional[str]
    details: Optional[Dict[str, Any]]

# JSON 응답 모델 - 단가 비교
class CompareResponse(BaseModel):
    compare: Dict[str, float]
    cheapest: str

# JSON 응답 모델 - 과일 추천
class RecommandResponse(BaseModel):
    recommand_items: Dict[str, int]
    total_cost: float
    currency: str

# JSON 응답 모델 - 재고 상태
class StockResponse(BaseModel):
    stock_status: Dict[str, bool]
    available_stock: Dict[str, int]

# ============================================
# 프롬프트 템플릿 정의
# ============================================

PROMPT_TEMPLATE_JSON = {
    "비용계산": """
    요청 : {question}
    데이터 : {data}

    1. 각 항목의 비용을 계산하세요.
    2. 총액을 계산하고, 10,000원 이상 시 10% 할인을 적용하세요.
    3. JSON 형식으로 결과를 작성하세요:
    ```json
    {{
      "total_cost": 총액,
      "currency": "원",
      "details": {{
        "items": 항목별 비용,
        "discount_applied": 할인여부,
        "discount_amount": 할인금액
      }}
    }}
    ```
    """,
    
    "단가비교": """
    요청 : {question}
    데이터 : {data}

    1. 요청된 과일의 단가를 비교하세요.
    2. JSON 형식으로 결과를 작성하세요:
    ```json
    {{
      "compare": {{"과일": 단가}},
      "cheapest": "가장 저렴한 과일"
    }}
    ```
    """,
    
    "과일추천": """
    요청 : {question}
    데이터 : {data}

    1. 예산 내에서 구매 가능한 과일 조합을 추천하세요.
    2. JSON 형식으로 결과를 작성하세요:
    ```json
    {{
      "recommand_items": {{"과일": 수량}},
      "total_cost": 총액,
      "currency": "원"
    }}
    ```
    """,
    
    "재고상태": """
    요청 : {question}
    데이터 : {data}

    1. 재고를 확인하고, 구매 가능 여부를 작성하세요.
    2. JSON 형식으로 결과를 작성하세요:
    ```json
    {{
      "stock_status": {{"과일": 구매 가능 여부}},
      "available_stock": {{"과일": 현재 재고}}
    }}
    ```
    """
}

# ============================================
# 동적 체인 생성 함수
# ============================================

def create_dynamic_chain_json(request_type: str) -> LLMChain:
    if request_type not in PROMPT_TEMPLATE_JSON:
        raise ValueError(f"지원하지 않는 요청 유형: {request_type}")
    
    prompt = PromptTemplate(
        input_variables=['question', 'data'],
        template=PROMPT_TEMPLATE_JSON[request_type]
    )
    
    return LLMChain(llm=llm, prompt=prompt)

# ============================================
# JSON 응답 검증 함수
# ============================================

def parse_and_validate_response(request_type: str, response_text: str) -> Dict[str, Any]:
    try:
        json_start = response_text.find("```json")
        json_end = response_text.rfind("```")
        json_str = response_text[json_start + 7: json_end]
        temp = json.loads(json_str)

        if request_type == "비용계산":
            validated = CalculationResponse(**temp).dict()
        elif request_type == "단가비교":
            validated = CompareResponse(**temp).dict()
        elif request_type == "과일추천":
            validated = RecommandResponse(**temp).dict()
        elif request_type == "재고상태":
            validated = StockResponse(**temp).dict()
        else:
            raise ValueError("지원하지 않는 요청 유형입니다.")
            
        return validated
    
    except Exception as e:
        return {"error": str(e)}

# ============================================
# 사용자 요청 처리 함수
# ============================================

def process_user_request_json(request: PurchaseRequest) -> Dict[str, Any]:
    # 요청에 따른 질문 생성
    if request.request_type == "비용계산":
        question = f"구매 항목: {request.items}"
    elif request.request_type == "단가비교":
        question = f"단가 비교할 과일: {request.compare_item}"
    elif request.request_type == "과일추천":
        question = f"예산: {request.budget}원 내에서 구매 가능한 과일 추천"
    elif request.request_type == "재고상태":
        question = f"재고 확인 항목: {request.items}"
    else:
        raise ValueError(f"지원하지 않는 요청 유형: {request.request_type}")

    # 데이터 구성
    data = {
        "prices": FRUIT_PRICE,
        "stock": FRUIT_STOCK,
        "discount": {"threshold": DISCOUNT_THREASHOLD, "rate": DISCOUNT_RATE}
    }

    # 체인 생성 및 실행
    chain = create_dynamic_chain_json(request.request_type)
    result = chain.invoke({'question': question, 'data': data})

    # JSON 응답 파싱 및 검증
    response = parse_and_validate_response(request.request_type, result['text'])
    return response

# ============================================
# 실행 예제
# ============================================

# 예제 요청 데이터
test_request = PurchaseRequest(
    request_type="비용계산",
    items={"사과": 3, "오렌지": 5, "바나나": 10}
)

# 요청 처리 및 결과 출력
result = process_user_request_json(test_request)
print(f"결과: {result}")

 

3) RAG V2 (RAG++)

 - V1,V2 전체 파이프라인

 - V1  : Retriever  →  Generator
 - V2  : Retriever  →  Re-ranker  →  Generator

# 1) 기본 라이브러리 및 로깅 설정 -------------------------------------------
import os, re, glob, unicodedata, logging
import pdfplumber

from konlpy.tag import Okt                # 형태소 분석기 (KoNLPy)
from transformers import AutoTokenizer
from sentence_transformers import CrossEncoder

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.docstore.document import Document
from langchain_openai import ChatOpenAI

# pdfminer 경고 억제
logging.getLogger("pdfminer").setLevel(logging.ERROR)

# 2) 전역 상수 ----------------------------------------------------------------
# 2-1. 한글 불용어 (일반 + 법률 전용 샘플)
STOPWORDS = {
    # 기본 불용어
    "은","는","이","가","을","를","에","의","도","로","와","과","하고",
    "그","또는","하지만","그리고","그러나","따라서","즉","같다","있다","없다",
    # 법률 전용 샘플
    "판결","판시","주문","청구","원고","피고","대법원","사건","조","항","이유",
}

# 2-2. 임베딩/모델 경로 및 환경 변수
EMBED_MODEL_ID   = "jhgan/ko-sroberta-multitask"    # 한글 특화 SRoBERTa
RERANK_MODEL_ID  = "Dongjin-kr/ko-reranker"         # 한글 Cross-Encoder
LOCAL_FAISS_PATH = "./faiss_index"                  # 인덱스 저장 경로

# OpenAI Key ( .env )
OPENAI_API_KEY   = os.getenv("OPENAI_API_KEY", "my_key")

# 3) 전처리 함수 --------------------------------------------------------------
def preprocess_text(raw: str) -> str:
    """
    한글 일반 문서 전처리:
    · NFKC 정규화 → 영문/숫자/URL 제거 → 특수문자 정리 → 불용어 제거
    """
    if not isinstance(raw, str):
        return ""
    txt = unicodedata.normalize("NFKC", raw)
    txt = re.sub(r'\S+@\S+|http\S+|www\S+', ' ', txt)        # 이메일/URL
    txt = re.sub(r'[a-zA-Z]|[^\w\s\uAC00-\uD7A30-9]', ' ', txt)
    txt = re.sub(r'\s+', ' ', txt).strip()

    okt     = Okt()
    tokens  = [t for t in okt.morphs(txt) if t not in STOPWORDS]
    return ' '.join(tokens)

def preprocess_legal_text(raw: str) -> str:
    """
    법률 PDF 전용 전처리:
    · '주 문' 이후 본문만 남기고 헤더/각주/번호 제거 → 불용어 제거
    """
    start = raw.find("주 문")
    txt   = raw[start + len("주 문"):] if start != -1 else raw
    txt   = re.sub(r'-\s*\d+\s*-', ' ', txt)                 # 페이지 번호
    txt   = re.sub(r'\(\d+\)|[①-⑳]', ' ', txt)              # 괄호 숫자
    txt   = preprocess_text(txt)                             # 공통 전처리
    return txt

# 4) PDF 로드 & Chunking ------------------------------------------------------
def load_pdf_files(path: str, legal: bool=False) -> list[Document]:
    """
    지정 폴더의 PDF 파일을 읽어 텍스트를 추출 후 Document 리스트 반환.
    legal=True  →  법률 특화 전처리 함수 사용
    """
    docs = []
    for pdf_file in glob.glob(os.path.join(path, "*.pdf")):
        try:
            with pdfplumber.open(pdf_file) as pdf:
                pages = [p.extract_text() or "" for p in pdf.pages]
                text  = "\n".join(pages)
            if not text.strip():
                logging.warning(f"[SKIP] 빈 PDF: {pdf_file}")
                continue
            processed = preprocess_legal_text(text) if legal else preprocess_text(text)
            if processed:
                docs.append(Document(page_content=processed,
                                     metadata={"source": pdf_file}))
        except Exception as e:
            logging.error(f"[ERROR] {pdf_file}: {e}")
    return docs

def split_documents(documents: list[Document],
                    chunk_size: int=1000,
                    overlap: int=200) -> list[Document]:
    splitter = RecursiveCharacterTextSplitter(
        chunk_size   = chunk_size,
        chunk_overlap= overlap
    )
    return splitter.split_documents(documents)

# 5) Embedding & FAISS --------------------------------------------------------
def build_faiss_index(chunks: list[Document],
                      embed_model_id: str=EMBED_MODEL_ID,
                      save_path: str|None=None) -> FAISS:
    """
    · HuggingFace 임베딩 모델 로드 → 벡터 인덱스 생성
    · save_path 지정 시 .faiss / index.pkl 저장
    """
    emb = HuggingFaceEmbeddings(
        model_name = embed_model_id,
        model_kwargs={"device": "cpu"},            # GPU 사용 시 "cuda"
        encode_kwargs={"truncate": True}
    )
    vector_db = FAISS.from_documents(chunks, emb)
    if save_path:
        vector_db.save_local(save_path)
    return vector_db

# 6) 모델 초기화 --------------------------------------------------------------
def init_models():
    """
    • Cross-Encoder (Re-ranker)  
    • OpenAI LLM (Generator)
    """
    cross_enc = CrossEncoder(RERANK_MODEL_ID)
    llm = ChatOpenAI(
        model      = "gpt-4o-mini",   # 또는 "gpt-3.5-turbo"
        api_key    = OPENAI_API_KEY,
        temperature= 0.2,
        max_tokens = 256
    )
    return cross_enc, llm

# 7) 핵심 로직 : Retriever / Re-rank / QA ------------------------------------
def rerank_documents(query: str,
                     docs: list[Document],
                     cross_enc: CrossEncoder,
                     top_n: int=3,
                     thresh: float=0.05) -> list[Document]:
    """Cross-Encoder로 상위 n개 문서 재정렬"""
    if not docs:
        return []
    pairs  = [[query, d.page_content[:1000]] for d in docs]
    scores = cross_enc.predict(pairs)
    ranked = [(s, d) for s, d in zip(scores, docs) if s > thresh]
    ranked = sorted(ranked, key=lambda x: x[0], reverse=True)[:top_n]
    return [d for _, d in ranked]

def build_prompt(context: str, query: str) -> PromptTemplate:
    return PromptTemplate(
        input_variables=["context", "query"],
        template=(
            "다음 문서를 기반으로 질문에 답변하세요.\n"
            "-----\n{context}\n-----\n"
            "질문: {query}\n\n답변:"
        )
    )

def rag_v1_chain(query: str,
                 retriever,
                 llm,
                 keyword: str|None=None) -> str:
    """
    V1: Retriever → Generator
    """
    docs = retriever.get_relevant_documents(query)
    if keyword:
        docs = [d for d in docs if keyword in d.metadata.get("keywords", [])]
    if not docs:
        return "관련 문서를 찾지 못했습니다."
    context = "\n\n".join(d.page_content[:500] for d in docs)
    chain   = LLMChain(llm=llm, prompt=build_prompt(context, query))
    return chain.invoke({"query": query, "context": context})["text"]

def rag_v2_chain(query: str,
                 retriever,
                 cross_enc: CrossEncoder,
                 llm,
                 keyword: str|None=None) -> str:
    """
    V2: Retriever → Re-ranker → Generator
    """
    docs = retriever.get_relevant_documents(query)
    if keyword:
        docs = [d for d in docs if keyword in d.metadata.get("keywords", [])]
    docs = rerank_documents(query, docs, cross_enc)
    if not docs:
        return "관련 문서를 찾지 못했습니다."
    context = "\n\n".join(d.page_content[:500] for d in docs)
    chain   = LLMChain(llm=llm, prompt=build_prompt(context, query))
    return chain.invoke({"query": query, "context": context})["text"]

# 8) 실행 예시 ---------------------------------------------------------------
if __name__ == "__main__":
    # ① PDF 폴더 설정 (법률 예시는 legal=True)
    PDF_DIR      = "./pdfs"
    LEGAL_MODE   = False          # 법률 자료면 True
    KEYWORD_TAG  = "RAG"          # metadata 필터링 예시

    # ② 로드 → 전처리 → Chunk
    documents = load_pdf_files(PDF_DIR, legal=LEGAL_MODE)
    chunks    = split_documents(documents)

    # ③ 메타데이터(키워드) 예시 추가
    for c in chunks:
        c.metadata["keywords"] = [KEYWORD_TAG]

    # ④ 인덱스 생성
    vector_db = build_faiss_index(chunks, save_path=LOCAL_FAISS_PATH)
    retriever = vector_db.as_retriever(search_type="similarity",
                                       search_kwargs={"k": 10})

    # ⑤ 모델 초기화
    cross_enc, llm = init_models()

    # ⑥ 질의 테스트
    test_query = "RAG 시스템 성능 향상 방법은 무엇인가요?"
    print("=== V1 (단순) ========================================")
    print(rag_v1_chain(test_query, retriever, llm, KEYWORD_TAG))

    print("\n=== V2 (Re-rank) =====================================")
    print(rag_v2_chain(test_query, retriever, cross_enc, llm, KEYWORD_TAG))

 

4) 프롬프트 엔지니어링 응용

 

 

# ==========================
# OpenAI API Key 설정
# ==========================

open_ai_key = 'my_key'
client = openai.OpenAI(
    api_key=open_ai_key,
)

# ==========================
# Advanced CoT Template 함수
# ==========================
def advanced_cot_template(client, query):
    """
    고급 CoT(Chain of Thought) 템플릿 함수
    - 문제를 단계별로 풀고, 각 단계를 검토하여 최종 답변을 제공합니다.
    - 최종 답변 형식: "사과: x원, 오렌지: x원"
    
    Args:
        client (openai.OpenAI): OpenAI API 객체
        query (str): 사용자 입력 문제
        
    Returns:
        str: 최종 답변
    """
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "you are advanced reasoning system"},
            {"role": "user", "content": f"""
            다음 문제를 단계별로 풀어주세요, 답변 후 스스로 검토해 오류를 수정하세요, 400자 이내로 답변하세요.
            {query}
            1. 변수 정의.
            2. 방정식 설정.
            3. 계산 과정.
            4. 검토.
            5. 최종 답변은 "사과: x원, 오렌지: x원" 형식으로 작성하세요.
            """}
        ],
        max_tokens=400,
        temperature=0.7
    )
    return response.choices[0].message.content

# ==========================
# Few-Shot CoT 함수
# ==========================
def few_shot_cot(client, query):
    """
    Few-Shot CoT(Chain of Thought) 템플릿 함수
    - 예제를 통해 LLM이 학습할 수 있도록 few-shot 학습을 제공합니다.
    - 각 단계별로 문제를 풀이하고, 최종 답변을 수정합니다.
    
    Args:
        client (openai.OpenAI): OpenAI API 객체
        query (str): 사용자 입력 문제
        
    Returns:
        str: 최종 답변
    """
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "you are few shot reasoning system"},
            {"role": "user", "content": f"""
            다음 문제를 few shot으로 단계별로 풀어주세요, 아래 예제를 참고해 단계별로 답변하세요.
            
            예제 1 : 한 농부가 닭과 소를 합쳐 20마리 키운다, 다리 수는 50개이다. 닭과 소는 각각 몇 마리인가?
            1. 문제 분석: 닭과 소의 총 마리 수와 다리 수가 주어졌다. 닭과 소의 수를 구하는 것이 목표이다.
            2. 계산 단계: 닭을 D, 소를 C라고 하면 D + C = 20이고, 2D + 4C = 50 두 방정식을 풀어야 한다.
            3. 초기 답변: 닭은 10마리, 소는 10마리이다.
            4. 검토: 방정식을 풀면 닭은 15마리, 소는 5마리이다. 초기 답변이 틀렸다.
            5. 최종 답변: 닭은 15마리, 소는 5마리이다. 답을 수정했다.
            
            예제 2 : 사과 3개와 오렌지 2개는 13,000원 사과 2개와 오렌지 3개는 12,000원, 사과와 오렌지는 각각 얼마인가?
            1. 변수 정의:
                - 사과의 가격을 x원, 오렌지의 가격을 y원이라고 정의합니다.
            2. 방정식 설정:
                - 3x + 2y = 13000
                - 2x + 3y = 12000
            3. 계산 과정:
                - 두 방정식을 풀어 x와 y의 값을 구합니다.
            4. 검토:
                - x = 4000원, y = 3000원
            5. 최종 답변: "사과: 4000원, 오렌지: 3000원"
            
            이제 문제를 풀어보세요:
            {query}
            1. 변수 정의.
            2. 방정식 설정.
            3. 계산 과정.
            4. 검토.
            5. 최종 답변.
            """}
        ],
        max_tokens=400,
        temperature=0.7
    )
    return response.choices[0].message.content

# ==========================
# Example Usage
# ==========================
# 문제 정의
query_1 = "사과 3개와 오렌지 2개는 13,000원 사과 2개와 오렌지 3개는 12,000원, 사과와 오렌지는 각각 얼마인가?"
query_2 = "한 농부가 닭과 소를 합쳐 20마리 키운다, 다리 수는 50개이다. 닭과 소는 각각 몇 마리인가?"

# Advanced CoT 사용
print("Advanced CoT:")
print(advanced_cot_template(client, query_1))

# Few-Shot CoT 사용
print("\nFew-Shot CoT:")
print(few_shot_cot(client, query_2))

4. 13주차의 목표

높은 수준의 LLM 챗봇 구축하기 위해 모든 내용을 흡수하고 내껄로 만들자.