[AI] RAG와 LangChain을 활용한 Chatbot 구현(3)

👉RAG와 LangChain을 활용한 Chatbot 구현(2) 게시물 보러가기

 

지난 게시물에서 chat history와 few shot을 통해

 

1. 모델이 대화의 맥락을 파악하여 대답하고

2. 답변을 일관된 양식으로 제공하고

3. hallucination 가능성을 줄이고 답변의 정확도를 향상시켜

 

RAG의 전체적인 품질을 높였다.

 

마지막으로 우리가 작성한 모델에 evaluation(평가)를 추가해서 RAG의 신뢰도와 품질을 더 높이자.

 

RAG Evaluation 추가하기

지나치게 강조하는 것 같지만 LLM의 큰 숙적 중 하나는 계속 해서 언급했던 hallucination(환각) 현상이다. 환각으로 LLM이 잘못된 정보를 제공하는것을 최소화하기 위한 기법이 evaluation이다. evaluation을 통해 답변이 얼마나 도움이 되는지, 레퍼런스 답변과 비교했을 때 얼마나 정확한지 수치상으로 확인할 수 있다. evaluation tool로는 LangChain의 LangSmith를 사용한다.

 

RAG Evaluation 개념

RAG를 평가는 크게 두 가지로 나뉜다.

https://docs.smith.langchain.com/evaluation/concepts#retrieval-augmented-generation-rag

1. Reference output(참조 답변)이 요구되는 방식:

RAG 체인을 통해 생성된 답변을 모범 답안이라고 할 수 있는 레퍼런스 답변과 비교하여 유사한 정도를 평가하는 방식이다.

 

2. Reference output(참조 답변)이 요구되지 않는 방식:

위의 그림의 노란색, 초록색, 빨간색과 같이 답변이 특정 기준을 얼마나 충족하는지를 토대로 평가하는 방식이다. 프롬프트를 활용해서 나온 답변이 얼마나 타당한지 자체적으로 평가하는 방식이다.

 

RAG evaluation을 적용하는 방식에도 3가지가 있다.

 

1️⃣ Offline evaluation:

https://docs.smith.langchain.com/evaluation/concepts#offline-evaluation

✅ dataset:

미리 작성하는 답지와 같다. 이러한 질문이 들어오면 이렇게 답변하면 된다를 예시로 적어놓는 것이다.
간단하게 예를 들자면 아래가 하나의 dataset이 될 수 있겠다.

질문: 1+1을 계산하면 뭐가 나오나요?
답변: 1+1을 계산하면 2가 나옵니다!

few shot과 비슷하다고 생각할 수 있으나, 사용 목적에 있어 조금 다르다. few shot은 모델이 답변을 참고하여 답변 스타일이나 형식을 맞춰 답변할 수 있도록 하는게 목적이고, rag evaluation에서의 dataset은 모델이 생성한 답변이 미리 작성한 dataset과 얼마나 가까운지 점수를 매겨 평가하는 것이 목적이다!

미리 수집한 질문과 답변으로 이루어진 dataset들을 기반으로 응용 프로그램을 실행했을 때 나오는 출력 값을 dataset의 레퍼런스 답변과 비교해서 평가하는 방식이다. 실시간으로 측정하는 것이 아닌, dataset을 미리 수집해서 평가 값을 내는 것이기 때문에 오프라인 평가라고 불린다.

 

2️⃣ Online evaluation:

https://docs.smith.langchain.com/evaluation/concepts#online-evaluation

Offline evaluation과 반대되는 개념으로 배포된 프로그램의 결과를 실시간으로 평가하는 방식이다. 실제로 유저가 프로그램을 사용하면서 input 입력 시에 평가를 실시간으로 수행한다. 즉 유저와 프로그램 간의 상호작용을 통해 평가를 수행하기 때문에 미리 작성한 dataset과 레퍼런스 답변이 필요 없다. 유저의 실사용을 통해 작성되는 질문과 출력되는 답변을 평가하기 때문이다.

 

3️⃣ Pairwise evaluation:

서로 다른 체인에서 생성된 답변에 대한 평가를 할 때 사용된다. 두 답변을 비교해서 어떤 답변이 더 자연스럽고 정확한가 같은 정확성 평가에도 사용되며 답변 포맷이나 스타일이 얼마나 모범답안과 비슷한가, 답변이 얼마나 일관성있게 생성되는가와 같은 스타일과 일관성 평가에도 사용된다.

 

RAG Evaluation 적용

먼저 dataset을 만들어보자. GPT한테 우리가 이전에 만들었던 KBO 야구 규정집 마크다운 파일 주면서 데이터셋 한 20개 정도 만들어주면 잘 만들어준다. 만든 파일을 마크다운 파일을 LangSmith의 데이터셋에 추가하면 된다.

RAG evaluation을 통해 평가할 항목은 총 4가지이다. 평가하는 기준이 되는 이 항목들을 evaluator라고 부른다.

https://docs.smith.langchain.com/evaluation/tutorials/rag#overview

아래의 evaluator들을 쉽게 이해하기 위해서 (평가하려는 대상 ↔️ 평가의 기준이 되는 대상)을 묶어서 생각하면 편하다. 그렇게 생각하는게 편하기도 하고 실제로 모범 도출 값(평가의 기준이 되는)과 비교하여 점수를 측정하는 것이 사실이기도 하다.

 

설명도 열심히 적었지만 그림으로 이해하는게 훨씬 편하고 빠르다.

 

✅LLM-as-judge:

LLM을 평가자로 활용하여 모델의 출력 답변을 자동으로 평가하는 방식. 사람이 직접 평가하는 대신 LLM이 생성된 답변을 분석하고 점수를 매기고 피드백을 제공한다.

 

1️⃣ Correctness:

RAG를 통해 최종 도출된 답변(response)이 실제 모범 답변(reference answer)과 얼마나 유사한가?를 측정한다. 이 때 유사도를 측정하기 위해 모범 답안으로 사용하는 정보가 우리가 앞서 생성한 데이터셋(dataset)이다. RAG 답변과 데이터셋의 답변은 LLM-as-judge(LLM을 활용하여 두 답변 간의 유사한 정도를 측정) 방식을 활용하여 최종 correctness를 산정한다.

 

2️⃣ Relevance:

RAG를 통해 생성된 답변(response)이 처음에 유저가 입력한 입력 값(input)을 얼마나 잘 처리할 수 있는지를 측정한다. 생성된 답변과 입력값 과의 연관성, 효용성을 토대로 LLM-as-judge 방식으로 평가하기 때문에 데이터셋이 필요 없다는 특징이 있다.

 

3️⃣ Groundness:

RAG를 통해 생성된 답변(response)이 우리가 retriever를 통해 검색한 문서(relevant documents)와 같은 문맥을 공유하는지 측정한다. 쉽게 말해서 만든 답변이 검색한 문서랑 같은 주제를 공유하는지, 생뚱맞은 소리를 하지는 않는지를 평가한다. LLM-as-judge 방식으로 검색 문서와 답변을 비교하여 LLM 충실도, 환각(hallucination)의 정도를 측정 및 평가한다.

 

4️⃣ Retrieval relevance:

유저가 입력한 쿼리와 retriever를 통해 도출된 검색된 문서 간의 연관성을 측정한다. 마찬가지로 LLM-as-judge 방식으로 평가한다.

 

공식문서를 참고해서 각 Correctness, Relevance, Groundness, Retrieval relevance를 평가해보았다.

엄... 모든 evaluator에서 만점을 받기는 하는데 일관성 있는 포맷으로 답변을 해주지 않는다. evaluation에 few-shot이 빠져서 그런 듯하니 few-shot 추가 후에 다시 돌려보았다.

레퍼런스 output이랑 다르게 출처 앞에 한줄 공백이 없는게 좀 불편하긴 한데 그래도 어느 정도 포맷을 지켜서 답변을 준다. 지금까지 작성한 evaluation 코드는 아래와 같다. 한국어 임베딩 처리 및 검색 성능은 Upstage가 더 좋아서 Upstage를 활용했다. 그 외에 evaluation 부분에서의 LLM-as-judge는 공식문서에서 활용한 OpenAI를 활용했다.

from langchain_core.prompts import ChatPromptTemplate, FewShotChatMessagePromptTemplate
from langchain_openai import ChatOpenAI
from langchain_upstage import ChatUpstage, UpstageEmbeddings
from langchain_pinecone import PineconeVectorStore
from langsmith import Client, traceable
from typing_extensions import Annotated, TypedDict
from fewshot_doc import answer_examples

# 문서를 불러오기 위한 retriever 설정
def get_retriever():
    
    index_name = "baseball-rules-index"

    # 데이터를 벡터화할 임베딩 모델 설정
    embedding = UpstageEmbeddings(model="solar-embedding-1-large")
    database = PineconeVectorStore.from_existing_index(index_name=index_name, embedding=embedding)
    retriever = database.as_retriever(search_kwargs={"k": 4})
    return retriever

# With langchain we can easily turn any vector store into a retrieval component:
retriever = get_retriever()
llm = ChatUpstage()

# Add decorator so this function is traced in LangSmith
@traceable()
def rag_bot(question: str) -> dict:
    # langchain Retriever will be automatically traced
    docs = retriever.invoke(question)

    docs_string = "".join(doc.page_content for doc in docs)
    instructions = f"""
        당신은 최고의 KBO 리그 야구 규칙 전문가입니다. 
        아래의 문서를 참고해서 사용자의 질문에 대한 답변을 해주세요.
        
        먄약에 야구 규칙과 관련이 없다면 "🚫야구 규칙에 대한 질문만 답변이 가능합니다."라고 답변해주세요.
        만약에 답변할 수 없다면 모른다고 답변해주세요.
        
        답변 시에 출처에 대해서도 명확하게 밝혀주시고, 사용자가 이해하기 쉽게 설명해주세요.
        답변의 길이는 2-3줄 정도로 제한해주세요.

        Documents:
        {docs_string}
    """

    example_prompt = ChatPromptTemplate.from_messages(
        [
            ("human", "{input}"),
            ("ai", "{answer}"),
        ]
    )
    
    few_shot_prompt = FewShotChatMessagePromptTemplate(
        example_prompt=example_prompt,
        examples=answer_examples,
    )
    
    few_shot_messages = few_shot_prompt.format(input=question)
    
    # langchain ChatModel will be automatically traced
    ai_msg = llm.invoke(
        [
            {"role": "system", "content": instructions},
            few_shot_messages,
            {"role": "user", "content": question},
        ],
    )

    return {"answer": ai_msg.content, "documents": docs}


client = Client()

# LangSmith에 추가한 데이터셋 이름
dataset_name = "baseball_rules_dataset"

# ✅Correctness

# Grade output schema
class CorrectnessGrade(TypedDict):
    # Note that the order in the fields are defined is the order in which the model will generate them.
    # It is useful to put explanations before responses because it forces the model to think through
    # its final response before generating it:
    explanation: Annotated[str, ..., "Explain your reasoning for the score"]
    correct: Annotated[bool, ..., "True if the answer is correct, False otherwise."]


# Grade prompt
correctness_instructions = """You are a teacher grading a quiz. 

You will be given a QUESTION, the GROUND TRUTH (correct) ANSWER, and the STUDENT ANSWER. 

Here is the grade criteria to follow:
(1) Grade the student answers based ONLY on their factual accuracy relative to the ground truth answer. 
(2) Ensure that the student answer does not contain any conflicting statements.
(3) It is OK if the student answer contains more information than the ground truth answer, as long as it is factually accurate relative to the  ground truth answer.

Correctness:
A correctness value of True means that the student's answer meets all of the criteria.
A correctness value of False means that the student's answer does not meet all of the criteria.

Explain your reasoning in a step-by-step manner to ensure your reasoning and conclusion are correct. 

Avoid simply stating the correct answer at the outset."""

# Grader LLM
grader_llm = ChatOpenAI(model="gpt-4o-mini", temperature=0).with_structured_output(
    CorrectnessGrade, method="json_schema", strict=True
)

def correctness(inputs: dict, outputs: dict, reference_outputs: dict) -> bool:
    """An evaluator for RAG answer accuracy"""
    answers = f"""      QUESTION: {inputs['question']}
GROUND TRUTH ANSWER: {reference_outputs['answer']}
RAG ANSWER: {outputs['answer']}"""

    # Run evaluator
    grade = grader_llm.invoke(
        [
            {"role": "system", "content": correctness_instructions},
            {"role": "user", "content": answers},
        ]
    )
    return grade["correct"]

# ✅Relevance

# Grade output schema
class RelevanceGrade(TypedDict):
    explanation: Annotated[str, ..., "Explain your reasoning for the score"]
    relevant: Annotated[
        bool, ..., "Provide the score on whether the answer addresses the question"
    ]


# Grade prompt
relevance_instructions = """You are a teacher grading a quiz. 

You will be given a QUESTION and a STUDENT ANSWER. 

Here is the grade criteria to follow:
(1) Ensure the STUDENT ANSWER is concise and relevant to the QUESTION
(2) Ensure the STUDENT ANSWER helps to answer the QUESTION

Relevance:
A relevance value of True means that the student's answer meets all of the criteria.
A relevance value of False means that the student's answer does not meet all of the criteria.

Explain your reasoning in a step-by-step manner to ensure your reasoning and conclusion are correct. 

Avoid simply stating the correct answer at the outset."""

# Grader LLM
relevance_llm = ChatOpenAI(model="gpt-4o-mini", temperature=0).with_structured_output(
    RelevanceGrade, method="json_schema", strict=True
)

# Evaluator
def relevance(inputs: dict, outputs: dict) -> bool:
    """A simple evaluator for RAG answer helpfulness."""
    answer = f"""      QUESTION: {inputs['question']}
STUDENT ANSWER: {outputs['answer']}"""
    grade = relevance_llm.invoke(
        [
            {"role": "system", "content": relevance_instructions},
            {"role": "user", "content": answer},
        ]
    )
    return grade["relevant"]

# ✅Groundness

# Grade output schema
class GroundedGrade(TypedDict):
    explanation: Annotated[str, ..., "Explain your reasoning for the score"]
    grounded: Annotated[
        bool, ..., "Provide the score on if the answer hallucinates from the documents"
    ]


# Grade prompt
grounded_instructions = """You are a teacher grading a quiz. 

You will be given FACTS and a STUDENT ANSWER. 

Here is the grade criteria to follow:
(1) Ensure the STUDENT ANSWER is grounded in the FACTS. 
(2) Ensure the STUDENT ANSWER does not contain "hallucinated" information outside the scope of the FACTS.

Grounded:
A grounded value of True means that the student's answer meets all of the criteria.
A grounded value of False means that the student's answer does not meet all of the criteria.

Explain your reasoning in a step-by-step manner to ensure your reasoning and conclusion are correct. 

Avoid simply stating the correct answer at the outset."""

# Grader LLM
grounded_llm = ChatOpenAI(model="gpt-4o-mini", temperature=0).with_structured_output(
    GroundedGrade, method="json_schema", strict=True
)


# Evaluator
def groundedness(inputs: dict, outputs: dict) -> bool:
    """A simple evaluator for RAG answer groundedness."""
    doc_string = "".join(doc.page_content for doc in outputs["documents"])
    answer = f"""      FACTS: {doc_string}
STUDENT ANSWER: {outputs['answer']}"""
    grade = grounded_llm.invoke(
        [
            {"role": "system", "content": grounded_instructions},
            {"role": "user", "content": answer},
        ]
    )
    return grade["grounded"]

# ✅Retrieval Relevance

# Grade output schema
class RetrievalRelevanceGrade(TypedDict):
    explanation: Annotated[str, ..., "Explain your reasoning for the score"]
    relevant: Annotated[
        bool,
        ...,
        "True if the retrieved documents are relevant to the question, False otherwise",
    ]


# Grade prompt
retrieval_relevance_instructions = """You are a teacher grading a quiz. 

You will be given a QUESTION and a set of FACTS provided by the student. 

Here is the grade criteria to follow:
(1) You goal is to identify FACTS that are completely unrelated to the QUESTION
(2) If the facts contain ANY keywords or semantic meaning related to the question, consider them relevant
(3) It is OK if the facts have SOME information that is unrelated to the question as long as (2) is met

Relevance:
A relevance value of True means that the FACTS contain ANY keywords or semantic meaning related to the QUESTION and are therefore relevant.
A relevance value of False means that the FACTS are completely unrelated to the QUESTION.

Explain your reasoning in a step-by-step manner to ensure your reasoning and conclusion are correct. 

Avoid simply stating the correct answer at the outset."""

# Grader LLM
retrieval_relevance_llm = ChatOpenAI(model="gpt-4o-mini", temperature=0).with_structured_output(
    RetrievalRelevanceGrade, method="json_schema", strict=True
)

def retrieval_relevance(inputs: dict, outputs: dict) -> bool:
    """An evaluator for document relevance"""
    doc_string = "".join(doc.page_content for doc in outputs["documents"])
    answer = f"""      FACTS: {doc_string}
QUESTION: {inputs['question']}"""

    # Run evaluator
    grade = retrieval_relevance_llm.invoke(
        [
            {"role": "system", "content": retrieval_relevance_instructions},
            {"role": "user", "content": answer},
        ]
    )
    return grade["relevant"]


def target(inputs: dict) -> dict:
    return rag_bot(inputs["question"])

experiment_results = client.evaluate(
    target,
    data=dataset_name,
    evaluators=[correctness, groundedness, relevance, retrieval_relevance],
    experiment_prefix="baseball-rules-evaluator",
    metadata={"version": "baseball rules v1, gpt-4o-mini"},
)

langsmith evaluation 대시보드에서 각 실행 회차 마다의 evaluation 결과를 그래프로 도식화 해서 확인 가능하며 회차별 evaluator 점수 또한 확인 가능하다.

 

Streamlit을 통해 배포

지금까지 만든 챗봇 프로그램을 streamlit을 통해 배포해보자. 먼저 streamlit을 설치하고 streamlit을 실행시키기 위한 코드를 따로 작성하였다. 

 

✅ Streamlit:

파이썬 기반의 오픈소스 라이브러리로 데이터 애플리케이션이나 대시보드를 빠르고 쉽게 만들 수 있도록 해주는 프레임워크이다. 별도의 UI나 프론트 코드 작업 없이 파이썬으로 작성한 코드를 실행하기만 하면 애플리케이션을 만들어 주는 방식이다. 주로 데이터 분석, 인공지능 모델 시각화 작업에 많이 사용된다.

pip install streamlit

import streamlit as st
from llm import get_ai_response

st.set_page_config(page_title="야구 규칙 챗봇", layout="wide")
st.title("⚾️야구 규칙 챗봇")
st.caption("KBO 야구 규칙에 대한 모든 것을 물어보세요!")

# session_state에 챗봇과 나눈 채팅 기록이 존재하지 않으면 저장하는 빈 배열 생성
if "message_list" not in st.session_state:
    st.session_state.message_list = []
    
# 유저와 챗봇의 채팅 기록을 모두 출력
for chat in st.session_state.message_list:
    with st.chat_message(chat["role"]):
        st.write(chat["content"])
    
# 사용자의 입력 받기
if user_question := st.chat_input(placeholder="질문을 입력해 주세요!"):
    
    # 채팅이 "user"면 질문을 출력
    with st.chat_message("user"):
        st.write(user_question)
    # 유저의 입력 message_list에 추가
    st.session_state.message_list.append({"role": "user", "content": user_question})
    
    # 챗봇의 답변 생성
    with st.spinner("잠시만 기다려 주세요... 답변을 생성하는 중입니다..."):
        ai_response = get_ai_response(user_question)
        
        # 채팅이 "ai"면 답변을 출력
        with st.chat_message("ai"):
            ai_message = st.write_stream(ai_response)
            # 챗봇의 답변 message_list에 추가
            st.session_state.message_list.append({"role": "ai", "content": ai_message})

 

우리가 작성한 chatbot.py를 통해 유저의 입력을 받아서 rag 체인 단으로 넘겨서 답변을 받아내고 이를 다시 streamlit의 화면에 출력한다. streamlit을 통해 프론트엔드 단을 간단하게 구축하는 것이다. 

작성한 chatbot.py 코드를 로컬에서 실행시키면 아래와 같은 결과가 나온다!

실행 중...

결과

잘 돌아가는 것은 확인했으니 본격적으로 이를 배포해보자. 배포를 하기 위해서는 작성한 파일을 깃허브 repository에 업로드 하고 streamlit에서 app을 생성 후 깃허브 repo 주소를 추가하여 진행한다.

🚨 가상환경에서 설치한 파이썬 패키지들은 모두 pip freeze를 통해 requirements.txt 파일을 만들어서 함께 레포에 푸시해주자.

Advanced settings에서 프로그램을 돌리는 데에 필요한 secret key들을 입력해주면 된다. 로컬에서 테스트 할 때 .env파일에 추가했던 secret key들을 모두 여기에 추가해주자(OpenAI API 키, Langchain API 키 등).

 

이로써 chatbot 업로드 까지 끝났다. app 생성 시 지정한 url로 들어가면 챗봇을 확인할 수 있다. 애플리케이션 관련 설정은 My apps 탭에서 가능하다.

 

🙇‍♂️코드 및 파일은 모두 깃허브 레포에 올려두었습니다. 작성한 코드 및 파일은 여기서 확인 가능합니다!

 

References

https://docs.smith.langchain.com/evaluation/concepts#retrieval-augmented-generation-rag

https://docs.smith.langchain.com/evaluation/tutorials/rag

https://docs.streamlit.io/