더 나은 세상을 위하여…

LangChain에서 날짜와 시간 데이터를 처리하는 데 유용한 도구 중 하나가 DatetimeOutputParser입니다. 이 파서는 언어 모델의 출력을 구조화된 날짜 및 시간 형식으로 변환하여, 애플리케이션에서 일관된 데이터 처리를 가능하게 합니다.

DatetimeOutputParser는 LangChain의 출력 파서(output parser) 모듈 중 하나로, 언어 모델의 텍스트 출력을 Python의 datetime 객체로 변환합니다. 이는 날짜나 시간을 포함한 응답을 처리할 때 유용하며, 예를 들어 사용자 입력에서 “다음 주 월요일”이나 “2025년 4월 22일” 같은 표현을 표준화된 형식으로 변환할 수 있습니다.

주요 특징

• 형식 지정 가능: 출력 형식을 사용자가 정의할 수 있습니다(예: %Y-%m-%d %H:%M:%S).
• 유연한 입력 처리: 비정형 텍스트에서도 날짜 정보를 추출합니다.
• EXAONE 3.5와의 호환성: EXAONE 3.5의 자연어 처리 능력과 결합하여 높은 정확도를 제공합니다.

다음은 DatetimeOutputParser를 사용하여 언어 모델의 출력을 파싱하는 간단한 예제입니다.

예제

LangChain에서 DatetimeOutputParser를 사용하는 간단한 예제를 설명하겠습니다

import re
from langchain.output_parsers import DatetimeOutputParser
from langchain.prompts import PromptTemplate
from langchain_ollama import ChatOllama
from datetime import datetime

# LLM 모델 초기화
llm = ChatOllama(model="exaone3.5")

# DatetimeOutputParser 초기화 및 포맷 지정
output_parser = DatetimeOutputParser()
output_parser.format = "%Y-%m-%d"

# 포맷 지침 생성
format_instructions = output_parser.get_format_instructions()

# 오늘 날짜를 프롬프트에 명시적으로 전달
today_str = datetime.today().strftime('%Y-%m-%d')

# 프롬프트 템플릿 정의 (포맷 지침 포함, 반드시 날짜만 출력하도록 강조)
prompt = PromptTemplate(
    template=(
        f"오늘은 {today_str}\n"
        "아래의 질문에 답할 때 반드시 '{format_instructions}'를 따르세요.\n"
        "반드시 날짜만 출력하고, 다른 설명이나 문장은 절대 추가하지 마세요.\n"
        "질문: {question}\n"
        "답변:"
    ),
    input_variables=["question"],
    partial_variables={"format_instructions": format_instructions}
)

# 날짜만 추출하는 함수
def extract_date(text):
    match = re.search(r"\d{4}-\d{2}-\d{2}", text)
    if match:
        return match.group(0)
    else:
        raise ValueError(f"날짜를 찾을 수 없습니다: {text}")

# 체인 구성
def run_chain(question):
    prompt_text = prompt.format(question=question)
    llm_response = llm.invoke(prompt_text)
    # LLM 응답에서 실제 텍스트 추출 (AIMessage 등 객체일 수 있음)
    if hasattr(llm_response, "content"):
        response_text = llm_response.content
    else:
        response_text = str(llm_response)
    # 날짜만 추출
    date_str = extract_date(response_text)
    # 파싱
    result = output_parser.parse(date_str)
    return result

# 질문 실행
question = "LG전자의 창립연도는?"
result = run_chain(question)

print(result)

2025-04-28 00:00:00

또 다른 질문:

# 질문 실행
question = "LG전자의 창립연도는?"
result = run_chain(question)

print(result)

1958-01-01 00:00:00

실제 활용 사례

DatetimeOutputParser는 다양한 애플리케이션에서 활용될 수 있습니다. 아래는 몇 가지 예입니다:

• 일정 관리 챗봇: 사용자가 “다음 주 화요일 10시에 회의 예약”이라고 말하면, 이를 파싱하여 캘린더에 추가.
• 데이터 분석: 로그 데이터에서 날짜 정보를 추출해 분석.
• 여행 플래너: “6월 첫째 주에 파리 여행” 같은 요청을 처리해 정확한 날짜를 제공.

주의사항 및 최적화 팁

• 프롬프트 명확성: 프롬프트에 출력 형식을 명확히 지정하면 더 정확한 결과를 얻을 수 있습니다.
• 문화적 차이 고려: 날짜 형식은 지역에 따라 다를 수 있으므로, 대상 사용자에 맞는 형식을 지정하세요(예: %d/%m/%Y vs %Y-%m-%d).
• 성능 최적화: 대량의 데이터를 처리할 때는 파싱 속도를 고려하여 배치 처리를 구현하는 것이 좋습니다.

PandasDataFrameOutputParser는 특히 표 형태의 데이터를 처리하거나 분석해야 할 때 유용하며, 데이터 과학 및 분석 작업에서 강력한 도구로 활용됩니다.

PandasDataFrameOutputParser는 LangChain의 출력 파서 중 하나로, LLM의 텍스트 출력을 Pandas 데이터프레임 형태로 구조화합니다. Pandas는 Python에서 데이터 분석을 위한 강력한 라이브러리로, 데이터프레임은 행과 열로 구성된 표 형태의 데이터 구조입니다. 이 파서를 사용하면 LLM 모델이 생성한 비정형 텍스트를 데이터프레임으로 변환하여 데이터 분석, 시각화, 또는 추가 처리를 쉽게 수행할 수 있습니다.

주요 특징

• 구조화된 출력: 텍스트 기반의 LLM 출력을 표 형태로 변환.
• 유연한 데이터 처리: 다양한 형식의 입력을 처리하여 데이터프레임으로 변환.
• Pandas 통합: 데이터프레임의 강력한 기능을 활용하여 데이터 조작 및 분석 가능.

PandasDataFrameOutputParser 사용 방법

PandasDataFrameOutputParser는 LLM의 출력을 데이터프레임으로 변환하기 위해 다음과 같은 단계를 거칩니다:

1. 프롬프트 템플릿을 정의하여 모델이 구조화된 출력을 생성하도록 유도.
2. PandasDataFrameOutputParser를 사용하여 출력을 파싱.
3. 결과 데이터프레임을 활용하여 분석 또는 후속 작업 수행.

예제: 데이터프레임 출력 생성

아래는 EXAONE-3.5 모델과 PandasDataFrameOutputParser를 사용하여 간단한 데이터프레임을 생성하는 예제입니다. 이 예제에서는 학생들의 이름과 점수를 포함한 데이터프레임을 생성합니다.

from langchain_ollama import ChatOllama
from langchain.output_parsers import PandasDataFrameOutputParser
from langchain.prompts import PromptTemplate
import pandas as pd

# 1. 데이터프레임 생성
data = {
    "학생": ["Alice", "Bob", "Charlie"],
    "점수": [85, 90, 78]
}
df = pd.DataFrame(data)

# 2. PandasDataFrameOutputParser 초기화 (dataframe 인자 필수)
parser = PandasDataFrameOutputParser(dataframe=df)

# 3. 프롬프트 템플릿 정의 (query를 입력 변수로 사용)
prompt = PromptTemplate(
    template=(
        "다음 데이터프레임에서 '{query}'에 해당하는 정보를 "
        "아래의 출력 형식({format_instructions})에 맞게 반환하세요.\n"
        "데이터프레임:\n{df}\n"
        "출력 형식 외의 설명이나 예시는 절대 포함하지 마세요."
    ),
    input_variables=["query"],
    partial_variables={
        "format_instructions": parser.get_format_instructions(),
        "df": df.to_string(index=False)
    }
)

# 4. 체인 구성
chain = prompt | ChatOllama(model="exaone3.5", temperature=0) | parser

# 5. 체인 실행 (예시: 전체 표 반환)
result = chain.invoke({"query": "평균 점수를 알려주세요."})

# 6. 결과 출력
print(result)

{‘mean’: 84.33333333333333}

• 모델 초기화: ChatOllama를 사용하여 EXAONE-3.5 모델을 로드합니다. temperature=0은 모델의 출력을 일관되게 유지합니다.
• 프롬프트 템플릿: PromptTemplate을 사용하여 모델이 데이터를 생성하도록 지시합니다. parser.get_format_instructions()은 파서가 기대하는 출력 형식을 제공합니다.
• 체인 구성: 프롬프트, LLM, 파서를 연결하여 체인을 구성합니다.
• 결과 처리: 체인을 실행하여 모델의 출력을 데이터프레임으로 변환합니다.

주의사항 및 최적화 팁

• 프롬프트 설계: 모델이 기대한 형식으로 출력을 생성하도록 명확한 프롬프트를 작성하세요. 
• 출력 형식 확인: parser.get_format_instructions()를 사용하여 파서가 요구하는 정확한 출력 형식을 확인하세요.
• 성능 최적화: 대량의 데이터를 처리할 때는 모델의 응답 시간을 고려하여 배치 처리를 구현하거나, 데이터 크기를 제한하세요.
• 오류 처리: 모델이 비정형 출력을 생성할 경우를 대비해 예외 처리를 추가하세요. 예를 들어, try-except 블록을 사용하여 파싱 오류를 관리할 수 있습니다.

LangChain의 JsonOutputParser는 LLM의 출력을 특정 JSON 스키마에 맞게 파싱하고 구조화하는 데 도움을 주는 강력한 도구입니다. 이 챕터에서는 Ollama를 기반으로 한 LangChain 환경에서 JsonOutputParser를 사용하는 방법과 EXAONE 3.5 모델을 활용한 실전 예제를 다룹니다.

JsonOutputParser는 사용자가 정의한 JSON 스키마에 따라 LLM의 출력을 구조화된 JSON 객체로 변환합니다. 이를 통해 비정형 텍스트 출력을 프로그램에서 쉽게 사용할 수 있는 데이터로 변환할 수 있습니다.

JsonOutputParser의 역할과 필요성

LLM은 일반적으로 자유 형식의 텍스트를 생성합니다. 하지만 애플리케이션에서는 JSON과 같은 구조화된 데이터 형식이 요구되는 경우가 많습니다. 예를 들어, 사용자 정보를 JSON 객체로 추출하거나, 특정 데이터 필드를 API로 전송해야 할 때 JsonOutputParser는 다음과 같은 이점을 제공합니다:

• 구조화된 출력 보장: 사용자가 정의한 스키마에 맞는 JSON 객체를 생성.
• 오류 감소: 비정형 텍스트를 수동으로 파싱할 때 발생할 수 있는 오류를 줄임.
• 효율적인 통합: JSON 출력을 통해 다른 시스템과의 통합을 간소화.
• 유연성: 복잡한 중첩 스키마나 선택적 필드도 처리 가능.

JsonOutputParser 설정 및 사용법

LangChain에서 JsonOutputParser를 사용하려면 다음 단계를 따릅니다:

1. 필요한 모듈 가져오기: JsonOutputParser와 함께 PromptTemplate, 그리고 Ollama 기반의 LLM을 초기화합니다.
2. JSON 스키마 정의: 출력하고자 하는 JSON 구조를 Pydantic 모델 또는 딕셔너리 형태로 정의합니다.
3. 프롬프트 템플릿 설정: LLM이 JSON 형식으로 응답하도록 유도하는 프롬프트를 작성합니다.
4. 파이프라인 구성: 프롬프트, LLM, 그리고 JsonOutputParser를 연결하여 체인을 구성합니다.

다음은 EXAONE 3.5 모델을 사용하여 사람 정보를 JSON 형식으로 추출하는 예제입니다. 이 예제는 사용자가 입력한 텍스트에서 이름, 나이, 직업 정보를 추출합니다.

from langchain_core.prompts import PromptTemplate
from langchain_ollama import OllamaLLM
from langchain_core.output_parsers import JsonOutputParser
from pydantic import BaseModel, Field

# 출력 스키마 정의
class Person(BaseModel):
    name: str = Field(description="사람의 이름")
    age: int = Field(description="사람의 나이")
    occupation: str = Field(description="사람의 직업")

# 프롬프트 템플릿 설정
prompt = PromptTemplate.from_template(
    """다음 텍스트에서 사람의 이름, 나이, 직업을 JSON 형식으로 추출하세요:
    {input}

    출력은 다음 JSON 스키마를 따라야 합니다:
    {format_instructions}
    """
)

# LLM 초기화 (EXAONE 3.5)
llm = OllamaLLM(model="exaone3.5", format="json", temperature=0.1)

# JSON 출력 파서 설정
parser = JsonOutputParser(pydantic_object=Person)

# 체인 구성
chain = prompt | llm | parser

# 입력 텍스트
input_text = "김민수는 35세이고, 소프트웨어 엔지니어로 일하고 있습니다."

# 체인 실행
response = chain.invoke({
    "input": input_text,
    "format_instructions": parser.get_format_instructions()
})

print(response)

{‘name’: ‘김민수’, ‘age’: 35, ‘occupation’: ‘소프트웨어 엔지니어’}

• Pydantic 모델 (Person): 출력 JSON의 구조를 정의합니다. 각 필드에는 설명을 추가하여 LLM이 올바른 데이터를 추출하도록 돕습니다.
• 프롬프트 템플릿: 입력 텍스트와 JSON 스키마 형식을 LLM에 전달합니다. parser.get_format_instructions()는 스키마를 문자열로 변환하여 프롬프트에 삽입합니다.
• OllamaLLM: EXAONE 3.5 모델을 JSON 출력 모드로 설정(format=”json”)하여 구조화된 출력을 보장합니다.
• 체인: 프롬프트, LLM, 파서를 연결하여 입력부터 JSON 출력까지의 파이프라인을 구성합니다.

고급 사용 사례

복잡한 데이터 구조를 다룰 때는 중첩된 JSON 스키마가 필요할 수 있습니다. 예를 들어, 여러 사람의 정보를 포함한 리스트를 추출하는 경우를 살펴보겠습니다.

from typing import List

# 중첩 스키마 정의
class PeopleData(BaseModel):
    people: List[Person] = Field(description="사람들의 정보 리스트")

# 프롬프트 템플릿
prompt = PromptTemplate.from_template(
    """다음 텍스트에서 사람들의 정보를 JSON 형식으로 추출하세요:
    {input}

    출력은 다음 JSON 스키마를 따라야 합니다:
    {format_instructions}
    """
)

# 파서 및 체인 설정
parser = JsonOutputParser(pydantic_object=PeopleData)
chain = prompt | llm | parser

# 입력 텍스트
input_text = """
김민수는 35세이고, 소프트웨어 엔지니어입니다.
이영희는 28세이고, 디자이너로 일하고 있습니다.
"""

# 체인 실행
response = chain.invoke({
    "input": input_text,
    "format_instructions": parser.get_format_instructions()
})

print(response)

{‘people’: [{‘name’: ‘김민수’, ‘age’: 35, ‘occupation’: ‘소프트웨어 엔지니어’}, {‘name’: ‘이영희’, ‘age’: 28, ‘occupation’: ‘디자이너’}]}

오류 처리 및 디버깅

JsonOutputParser는 유효한 JSON을 생성하지 못할 경우 예외를 발생시킵니다. 이를 처리하기 위해 try-except 블록을 사용하는 것이 좋습니다:

try:
    response = chain.invoke({
        "input": input_text,
        "format_instructions": parser.get_format_instructions()
    })
    print(response)
except Exception as e:
    print(f"JSON 파싱 오류: {e}")

{‘people’: [{‘name’: ‘김민수’, ‘age’: 35, ‘occupation’: ‘소프트웨어 엔지니어’}, {‘name’: ‘이영희’, ‘age’: 28, ‘occupation’: ‘디자이너’}]}

또한, LangSmith와 같은 도구를 사용하면 체인 실행 과정을 추적하여 디버깅을 용이하게 할 수 있습니다.

EXAONE 3.5와의 최적화 팁

EXAONE 3.5는 한국어 처리에 특화된 모델로, JSON 출력에서도 높은 성능을 발휘합니다. 다음은 최적화 팁입니다:

• 명확한 프롬프트: 한국어로 작성된 명확하고 구체적인 프롬프트를 사용하세요. 예: “JSON 형식으로만 응답하세요”를 명시.
• 온도(Temperature) 조정: temperature=0.1과 같이 낮은 값을 설정하여 출력의 일관성을 높임.
• 스키마 설명 강화: Pydantic 필드의 description을 상세히 작성하여 모델이 올바른 데이터를 추출하도록 유도.
• JSON 모드 활성화: OllamaFunctions에서 format=”json”을 반드시 설정.

주의사항

• 모델 한계: EXAONE 3.5는 뛰어난 성능을 제공하지만, 매우 복잡한 스키마나 모호한 입력에서는 추가 프롬프트 엔지니어링이 필요할 수 있습니다.
• Ollama JSON 모드 성능: Ollama의 JSON 모드는 때때로 느리거나 공백을 과도하게 생성할 수 있습니다. 최신 Ollama 버전을 사용하는 것이 좋습니다.
• 스키마 검증: Pydantic 모델을 사용할 때는 필수 필드와 선택 필드를 명확히 정의하여 유연성을 확보하세요.

참고) Pydantic 없이 사용하기

Pydantic 없이도 이 기능을 사용할 수 있습니다. 이 경우 JSON을 반환하도록 요청하지만, 스키마가 어떻게 되어야 하는지에 대한 구체적인 정보는 제공하지 않습니다.

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import JsonOutputParser
from langchain_ollama import ChatOllama

llm_model = ChatOllama(model="exaone3.5", temperature=0)

# 질의 작성
question = "화성 이주 최신 계획을 알려주세요. `description`에, 관련 키워드는 `hashtags`에 담아주세요."

# JSON 출력 파서 초기화
parser = JsonOutputParser()

# 프롬프트 템플릿을 설정합니다.
prompt = ChatPromptTemplate.from_messages([
      ("system", "당신은 친절한 AI 어시스턴트 입니다. 질문에 간결하게 답변하세요."),
      ("user", "#Format: {format_instructions}\n\n#Question: {question}"),
])

# 지시사항을 프롬프트에 주입합니다.
prompt = prompt.partial(format_instructions=parser.get_format_instructions())

# 프롬프트, 모델, 파서를 연결하는 체인 생성
chain = prompt | llm_model | parser

# 체인을 호출하여 쿼리 실행
response = chain.invoke({"question": question})

# 출력을 확인합니다.
print(response)

{‘description’: “현재 공개된 가장 구체적인 화성 이주 계획 중 하나는 NASA의 ‘아르테미스 프로그램’과 민간 기업들의 노력을 포함합니다. 아르테미스는 장기적으로 인간의 지속 가능한 화성 정착을 목표로 하며, 초기 단계로는 달 주변에서의 경험을 쌓고 있습니다. 구체적인 이주 일정은 아직 확정되지 않았으나, 2030년대 후반이나 2040년대 초반에 인간의 화성 표면 탐사 및 임시 정착지 구축을 목표로 하고 있습니다. 이 과정에서 생명 유지 시스템, 자원 재활용 기술, 그리고 건강 관리 시스템 개발이 핵심 과제로 부각되고 있습니다.”, ‘hashtags’: [‘#화성이주’, ‘#아르테미스프로젝트’, ‘#우주탐사’, ‘#지속가능한정착’, ‘#우주기술혁신’]}

StructuredOutputParser는 LangChain의 출력 파싱 모듈로, LLM의 텍스트 출력을 JSON, 딕셔너리, 또는 기타 구조화된 형식으로 변환합니다. 이를 통해 모델의 출력을 애플리케이션에서 쉽게 처리하거나 데이터베이스에 저장할 수 있습니다. EXAONE 3.5와 같은 고성능 모델은 복잡한 텍스트를 생성할 수 있지만, 이 텍스트를 구조화된 데이터로 변환하려면 명확한 파싱 전략이 필요합니다.

주요 특징

• 스키마 정의: 사용자가 원하는 출력 형식을 ResponseSchema 객체로 정의.
• 자동 파싱: LLM의 텍스트 출력을 정의된 스키마에 맞게 자동으로 매핑.
• 에러 처리: 잘못된 출력 형식을 처리하거나 기본값을 제공하는 기능.
• 프롬프트 통합: 프롬프트 템플릿에 파싱 지침을 포함하여 모델이 구조화된 출력을 생성하도록 유도.

StructuredOutputParser를 사용하려면 먼저 LangChain과 Ollama 환경을 설정해야 합니다. 아래는 EXAONE 3.5 모델을 사용한 기본 설정 예제입니다.

from langchain_ollama import OllamaLLM
from langchain.output_parsers import StructuredOutputParser, ResponseSchema
from langchain.prompts import PromptTemplate

# Ollama 모델 초기화 (EXAONE 3.5)
llm = OllamaLLM(model="exaone3.5")

ResponseSchema 정의

ResponseSchema는 출력의 각 필드와 그에 대한 설명을 정의합니다. 예를 들어, 책 추천 시스템에서 책 제목과 저자를 추출하려면 다음과 같이 설정할 수 있습니다.

# 응답 스키마 정의
response_schemas = [
    ResponseSchema(name="title", description="추천된 책의 제목"),
    ResponseSchema(name="author", description="추천된 책의 저자")
]

프롬프트 템플릿 생성

StructuredOutputParser는 프롬프트에 출력 형식을 명시적으로 포함시켜야 합니다. 이를 위해 PromptTemplate을 사용합니다.

# 프롬프트 템플릿
format_instructions = output_parser.get_format_instructions()
prompt_template = PromptTemplate(
    template="다음 주제에 맞는 책을 추천해 주세요: {topic}\n{format_instructions}",
    input_variables=["topic"],
    partial_variables={"format_instructions": format_instructions}
)

get_format_instructions() 메서드는 JSON 형식의 출력 지침을 생성하며, EXAONE 3.5가 이를 따라 구조화된 출력을 생성하도록 유도합니다.

StructuredOutputParser 사용 예제

아래는 사용자가 “인공지능” 주제에 대한 책 추천을 요청했을 때 StructuredOutputParser를 사용하여 결과를 파싱하는 예제입니다.

# 체인 구성
chain = prompt_template | llm | output_parser

# 사용자 입력
topic = "인공지능"

# 체인 실행
response = chain.invoke({"topic": topic})

# 결과 출력
print(response)

{‘title’: ‘Artificial Intelligence: A Guide for Thinking Humans’, ‘author’: ‘Melanie Mitchell’}

이 예제에서 EXAONE 3.5는 프롬프트에 포함된 형식 지침을 따라 JSON 형식의 텍스트를 생성하고, StructuredOutputParser는 이를 파싱하여 Python 딕셔너리로 반환합니다.

고급 사용 사례

더 복잡한 출력이 필요할 경우, 추가 필드와 데이터 유형을 정의할 수 있습니다. 예를 들어, 책 추천에 출판 연도와 장르를 추가하려면:

response_schemas = [
    ResponseSchema(name="title", description="추천된 책의 제목"),
    ResponseSchema(name="author", description="추천된 책의 저자"),
    ResponseSchema(name="year", description="출판 연도", type="integer"),
    ResponseSchema(name="genre", description="책의 장르")
]
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)

에러 처리

EXAONE 3.5가 예상과 다른 형식을 반환할 경우, StructuredOutputParser는 예외를 발생시킵니다. 이를 방지하기 위해 try-except 블록을 사용하거나, 기본값을 설정할 수 있습니다.

try:
    result = chain.invoke({"topic": topic})
except Exception as e:
    result = {"title": "추천 없음", "author": "없음"}

다중 출력 처리

여러 추천을 요청할 경우, ResponseSchema에 리스트 형태의 필드를 정의할 수 있습니다.

response_schemas = [
    ResponseSchema(name="recommendations", description="추천 책 목록", type="list")
]

EXAONE 3.5와의 최적화 팁

EXAONE 3.5는 고성능 한국어 처리 능력을 갖추고 있지만, 구조화된 출력을 생성하려면 프롬프트 디자인이 중요합니다. 다음은 최적화를 위한 팁입니다.

• 명확한 지침: 프롬프트에 JSON 형식의 예제를 포함하여 모델이 출력 형식을 이해하도록 돕습니다.

template = """다음 주제에 맞는 책을 추천해 주세요: {topic}
출력은 다음 JSON 형식으로 제공해 주세요:
{{"title": "책 제목", "author": "저자"}}
{format_instructions}"""

• 짧고 간결한 출력: EXAONE 3.5는 간결한 출력을 선호하므로, 불필요한 설명을 최소화합니다.
• 반복 테스트: 모델이 예상대로 구조화된 출력을 생성하는지 반복적으로 테스트합니다.

한계와 대안

StructuredOutputParser는 강력하지만, EXAONE 3.5가 프롬프트 지침을 완벽히 따르지 않을 경우 파싱 오류가 발생할 수 있습니다. 이 경우, 다음 대안을 고려할 수 있습니다.

• PydanticOutputParser: Pydantic 모델을 사용하여 더 엄격한 데이터 검증을 수행.
• Custom Parser: 특정 출력 패턴에 맞춘 사용자 정의 파서를 구현.
• 후처리 스크립트: 모델 출력에서 필요한 데이터를 추출하는 정규 표현식 또는 스크립트를 사용.