AICop_LangChain_v1.0.ipynb

aicop_langchain_v1-0.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "WKNY7UwP4q56",
        "9jJ4-aRh5B2X",
        "GRnfAVv-5Gct",
        "9cG3ma_C5S_1",
        "xa0e1WUcua_T",
        "ynQJ2aWAue4r",
        "TErPDEo9uy9k",
        "gsn0VQDyu7k5",
        "wQCIRzoXvBnP",
        "2z4hzx4_419V",
        "dZNBe_xtCBA4",
        "p-QQrXjoIMEm",
        "TGJn8dnNIQoW"
      ],
      "toc_visible": true,
      "authorship_tag": "ABX9TyNYDgKYpxNnFjnQSGGRt5U4",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/developer-zeromi/0c45682f1496a460bc974b4ea0ec4bb6/aicop_langchain_v1-0.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## LangChain Demo"
      ],
      "metadata": {
        "id": "JindF5Na4nbh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### LangChain이란?"
      ],
      "metadata": {
        "id": "9LdxO1tVq5BR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- LLM(대형 언어 모델)을 활용해 애플리케이션을 개발하기 위한 오픈 소스 프레임워크\n",
        "- 다양한 도구와 API를 통해 언어 모델(Language Model)을 연결(Chain)하여 애플리케이션을 만들 수 있는 도구\n",
        "- OpenAI, Cohere, Bloom, Huggingface 등 여러 대형 LLM 공급업체와의 상호작용을 간소화하기 위해 설계된 강력한 라이브러리"
      ],
      "metadata": {
        "id": "1hJeg8064M1a"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### LangChain은 왜 등장했을까?"
      ],
      "metadata": {
        "id": "WKNY7UwP4q56"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "이미 시장에 OpenAI의 ChatGPT, 앤쓰로픽의 끌로드, 구글 제미나이, 네이버 하이퍼클로바X 같은 대표 LLM을 제외하고도 수 많은 언어 모델이 매일 새롭게 나타나고 있으며 각 모델마다 고유한 기능과 전문성을 갖추고 있음. 사용 용도에 따라 특정 LLM을 연결해야 하는 경우가 있는데 이런 파이프라인을 구축하는 시나리오가 랭체인이 탄생하게 된 아이디어를 제공함"
      ],
      "metadata": {
        "id": "ikoNnmUe4tFP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### LangChain은 왜 사용할까?"
      ],
      "metadata": {
        "id": "2ZBS8BSh46bK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- 주로 LLM을 활용한 애플리케이션 개발을 간소화하고, 효율적으로 만들기 위해서임\n",
        "  1. 간편한 통합과 개발 간소화:  다양한 언어 모델과 API를 쉽게 통합할 수 있는 도구와 라이브러리를 제공해 복잡한 설정 불필요\n",
        "  2. 다양한 기능 지원: 텍스트 생성, 번역, 요약, 질의응답 등 다양한 언어 모델 기반 기능을 지원\n",
        "  3. 모듈화된 구조: 필요한 기능만 사용하거나, 향후 복잡한 기능을 추가하는 등 확장성이 좋음\n",
        "\n",
        "- 오픈AI와 같은 공급업체가 제공하는 모델 API 사용보다 유연하고 쉬움\n",
        "\n",
        "- 단순히 프롬프트를 보내고 응답을 기다리는 것 이상의 매개변수 조정, 프롬프트 보강, 응답 조정 등의 작업을 효율적으로 처리할 수 있도록 다양한 기능과 도구를 제공함\n",
        "  1. 프롬프트 체인을 통해 복잡한 프롬프트 시퀀스를 쉽게 구성할 수 있어 여러 단계의 질문과 응답을 관리할 수 있음\n",
        "  2. 입력 데이터를 전처리하는 다양한 모듈을 제공하고, 모델의 응답을 후처리해 모델과 사용자에 적합한 형식으로 변환할 수 있음\n",
        "  3. 여러 LLM 모델과 API를 통합할 수 있어, 특정 작업에 가장 적합한 모델을 선택하고 조합할 수 있음\n",
        "  4. 대화의 상태를 관리하고, 이전 대화의 컨텍스트를 유지하여 더 일관된 응답을 생성할 수 있음\n",
        "  5. 사용자 정의 기능을 쉽게 추가할 수 있는 인터페이스를 제공하여, 특정 요구사항에 맞춘 애플리케이션을 개발할 수 있음"
      ],
      "metadata": {
        "id": "IVlqEIi949WF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### LangChain을 사용할 수 있는 환경은?\n",
        "\n"
      ],
      "metadata": {
        "id": "9jJ4-aRh5B2X"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Python과 Javascript 기반 라이브러리를 제공함"
      ],
      "metadata": {
        "id": "UVzgOgHC5F03"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### LangChain의 주요 구성 요소는?"
      ],
      "metadata": {
        "id": "GRnfAVv-5Gct"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. LLM 추상화: 복잡성을 처리하고 불필요한 세부 사항을 숨기는 표준 인터페이스 제공\n",
        "\n",
        "2. 프롬프트: LLM에 태스크를 수행하라고 전달하는 명령어로 LangChain에서 제공하는 프롬프트 템플릿 클래스를 통해 컨텍스트와 쿼리를 구조화하여 수동 작성 필요 없음\n",
        "\n",
        "3. 체인: 랭체인 워크플로우의 핵심으로, 한 태스크의 출력을 다음 태스크의 입력으로 사용하는 순차 체인을 구성하거나 LLM 모델을 조합해 연결할 수 있음\n",
        "  - 데이터를 검색한 다음 → 검색한 텍스트를 요약한 다음 → 요약된 텍스트를 사용해 사용자가 제출한 질문에 답 하는 등 한 태스크의 출력이 다음 태스크의 입력으로 들어가는 순차 체인\n",
        "\n",
        "4. 인덱스: 학습 데이터 세트에 포함되지 않은 문서나 이메일 등의 외부 데이터를 인덱스라 하는데, 이를 처리할 수 있음\n",
        "  - 인덱스의 구성 요소는 도규먼트 로더, 벡터 데이터베이스, 텍스트 스플리터\n",
        "  - 도큐먼트 로더: 구글 드라이브, 드롭박스, 노션 문서 등에서 데이터 소스를 가져옴\n",
        "  - 벡터 데이터베이스: 효율적인 검색 수단 제공\n",
        "  - 텍스트 스플리터: 텍스트를 작은 덩어리로 분할 및 결합\n",
        "\n",
        "5. 메모리: 사용자가 LLM과 프롬프트 기반의 대화 중 사용자의 정보를 기억하고, 향후 상호 작용에 적용할 수 있음\n",
        "\n",
        "6. 에이전트:  LLM과 다른 데이터 소스를 조합하여 사용하는 서비스\n",
        "  - 대표적인 에이전트 서비스는 챗봇으로 LLM과 다른 데이터 소스(내부 정보, 고객 정보 등) 등 두 가지 이상의 도구를 조합해 사용 가능함"
      ],
      "metadata": {
        "id": "w4EP60bi5Md2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### LangChain으로 할 수 있는 일은?"
      ],
      "metadata": {
        "id": "9cG3ma_C5S_1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- 프롬프트 템플릿을 사용해 복잡한 학술 논문이나 자료 분석, 이메일 요점 등 다양한 유형의 텍스트를 요약하는 작업을 수행하는 요약 기능\n",
        "- 특정 문서나 전문 지식, 대화의 맥락을 기반으로 LLM이 관련 정보를 검색하고 유용한 답변을 제공할 수 있는 챗봇, Q&A 서비스\n",
        "- 전문 데이터를 이용해 보다 정확하고 최신 데이터를 제공하는 것 뿐만 아니라, 머신러닝을 위한 합성 데이터를 생성하는 등의 데이터 증강"
      ],
      "metadata": {
        "id": "vzE4eyvc5ZG0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 찍먹"
      ],
      "metadata": {
        "id": "-n3VkHAw4TcU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 기본 실습"
      ],
      "metadata": {
        "id": "KF0H-A5B-84u"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### 1. 필요한 라이브러리 설치"
      ],
      "metadata": {
        "id": "xa0e1WUcua_T"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- Python의 패키지 관리 도구인 pip를 사용해 langchain 패키지 설치\n"
      ],
      "metadata": {
        "id": "lBVXA0Ir_T9l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install langchain langchain_community"
      ],
      "metadata": {
        "collapsed": true,
        "id": "EZJ3pRVWuXxj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install huggingface_hub transformers datasets # 허깅 페이스 상호 작용, 사전 학습 모델 사용, 공개 데이터셋 사용"
      ],
      "metadata": {
        "id": "53wXxb3g30hQ",
        "collapsed": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 패키지 의존성 충돌 조치\n",
        "!pip install --force-reinstall huggingface_hub transformers datasets"
      ],
      "metadata": {
        "collapsed": true,
        "id": "xMuoaEmY01UL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### 2. 허깅페이스 토큰 발급"
      ],
      "metadata": {
        "id": "ynQJ2aWAue4r"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "  - 회원 가입: https://huggingface.co\n",
        "  - READ 토큰 발급: https://huggingface.co/docs/hub/security-tokens\n",
        "  - LLM의 READ 키 복사: https://huggingface.co/settings/tokens"
      ],
      "metadata": {
        "id": "wlweGpjr_Oof"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### 3. 허깅페이스 API 키 환경변수 설정"
      ],
      "metadata": {
        "id": "TErPDEo9uy9k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "\n",
        "# 허깅페이스 LLM Read Key\n",
        "os.environ['HUGGINGFACEHUB_API_TOKEN'] = '발급받은 API 키 입력'"
      ],
      "metadata": {
        "id": "pOwszxO-uZ-S"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### 4. 추론에 활용할 모델 선택"
      ],
      "metadata": {
        "id": "gsn0VQDyu7k5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "  - LLM 리더보드: https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard\n",
        "  - 한글 LLM 리더보드: https://huggingface.co/spaces/upstage/open-ko-llm-leaderboard"
      ],
      "metadata": {
        "id": "loxHmf0c_bP8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### 5. 허깅페이스 모델을 활용한 추론 예제"
      ],
      "metadata": {
        "id": "wQCIRzoXvBnP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1\n",
        "from langchain import LLMChain\n",
        "from langchain.prompts import PromptTemplate\n",
        "from langchain.llms import HuggingFaceHub\n",
        "\n",
        "# HuggingFace Repository ID\n",
        "repo_id = '42dot/42dot_LLM-SFT-1.3B'\n",
        "\n",
        "# 질의내용\n",
        "question = \"너는 어떤 AI 모델이야?\"\n",
        "\n",
        "# 템플릿\n",
        "template = \"\"\"Question: {question}\n",
        "\n",
        "Answer: \"\"\"\n",
        "\n",
        "# 프롬프트 템플릿 생성\n",
        "prompt = PromptTemplate(template=template, input_variables=[\"question\"])\n",
        "\n",
        "# HuggingFaceHub 객체 생성\n",
        "llm = HuggingFaceHub(\n",
        "    repo_id=repo_id,\n",
        "    model_kwargs={\"temperature\": 0.2,\n",
        "                  \"max_length\": 128}\n",
        ")\n",
        "\n",
        "# LLM Chain 객체 생성\n",
        "llm_chain = LLMChain(prompt=prompt, llm=llm)\n",
        "\n",
        "# 실행\n",
        "print(llm_chain.run(question=question))"
      ],
      "metadata": {
        "id": "KEqcs0WLvX1l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 활용 실습"
      ],
      "metadata": {
        "id": "F5VOLnyN5WqW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### 1. 컨텍스트 추가"
      ],
      "metadata": {
        "id": "2z4hzx4_419V"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- 더 정확하고 관련 된 응답을 생성할 수 있도록, 일관성을 유지시키거나 질문의 모호함을 해소할 수 있도록"
      ],
      "metadata": {
        "id": "-7FUpK06BmWP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "repo_id = '42dot/42dot_LLM-SFT-1.3B'\n",
        "\n",
        "question = \"너는 어떤 AI 모델이야?\"\n",
        "\n",
        "template = \"\"\"너는 AI 분야에 박식한 정말 도움이 되는 조수야.\n",
        "\n",
        "Question: {question}\n",
        "\n",
        "Answer: \"\"\"\n",
        "\n",
        "prompt = PromptTemplate(template=template, input_variables=[\"question\"])\n",
        "\n",
        "llm = HuggingFaceHub(\n",
        "    repo_id=repo_id,\n",
        "    model_kwargs={\"temperature\": 0.2,\n",
        "                  \"max_length\": 128}\n",
        ")\n",
        "\n",
        "llm_chain = LLMChain(prompt=prompt, llm=llm)\n",
        "\n",
        "print(llm_chain.run(question=question))"
      ],
      "metadata": {
        "id": "6pVuIouOvYvh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### 2. 매개변수 조정"
      ],
      "metadata": {
        "id": "dZNBe_xtCBA4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- temperature: 모델의 출력 확률 분포 조정\n",
        "  - 값이 낮을 수록 더 결정적이고, 높을수록 더 다양한 응답 생성\n",
        "  - 0.2 = 저는 언어 모델입니다.\n",
        "  - 0.7 = 저는 다양한 작업을 수행할 수 있는 언어 모델입니다.\n",
        "\n",
        "- max_length: 생성할 응답의 토큰(token)의 수 기준 최대 길이 설정\n",
        "  -  토큰은 일반적으로 단어, 부분 단어, 또는 문자 단위로 나뉘며, 모델마다 사용하는 토크나이저가 다르기 때문에, 동일한 문장이라도 모델에 따라 토큰의 수가 다를 수 있음\n",
        "\n",
        "- top_p: Top-p 샘플링을 사용하여 확률이 높은 토큰들만 선택하도록 함\n",
        "  - 모델이 학습한 토큰 중 문맥에 적합하고 더 많이 학습 된 패턴의 토큰이 샘플링 된다고 보면 됨\n",
        "  - (다양성)Top-p = 0.9: 확률 분포의 상위 90%에 해당하는 토큰들만 샘플링\n",
        "  - (일관성)Top-p = 0.5: 확률 분포의 상위 50%에 해당하는 토큰들만 샘플링\n",
        "\n",
        "- num_beams: 빔 서치 알고리즘에서 사용할 빔의 수를 설정 해 더 최적화 된 응답을 생성하지만 계산 비용 또한 증가\n",
        "  - 빔 서치 알고리즘: 가장 가능성이 높은 몇 가지 선택만을 계속해서 추적하는 방법\n",
        "  - 적은 num_beams (1): 저는 언어 모델입니다.\n",
        "  - 많은 num_beams (5): 저는 다양한 작업을 수행할 수 있는 언어 모델입니다. 예를 들어, 텍스트 생성, 번역, 요약 등을 할 수 있습니다.\n",
        "\n",
        "- repetition_penalty: 반복되는 단어의 확률을 낮추는 데 사용\n",
        "  - 값이 1인 경우: 반복 패널티가 적용되지 않음\n",
        "  - 값이 1보다 큰 경우: 이미 생성된 단어를 다시 생성할 확률이 낮아짐\n",
        "\n",
        "- length_penalty: 생성된 텍스트의 길이에 대한 페널티 적용해 더 짧거나 긴 텍스트를 선호하도록 함\n",
        "  - (간결함)length_penalty (0.8): 저는 언어 모델입니다.\n",
        "  - (자세함)length_penalty (1.2): 저는 다양한 작업을 수행할 수 있는 언어 모델입니다. 예를 들어, 텍스트 생성, 번역, 요약 등을 할 수 있습니다.\n",
        "\n",
        "- no_repeat_ngram_size: 특정 크기의 n-gram이 반복되지 않도록 해 텍스트의 다양성을 높임\n",
        "  - n-gram: 연속된 n개의 단어\n",
        "  - no_repeat_ngram_size (1): 저는 언어 모델입니다. 언어 모델입니다.\n",
        "  - no_repeat_ngram_size (3): 저는 언어 모델입니다.\n",
        "\n",
        "- early_stopping: True로 설정하면 모델이 더 이상 유효한 토큰을 생성할 수 없을 때 조기 종료해 너무 긴 문장을 생성하거나 의미 없는 반복을 제어함\n",
        "\n",
        "- do_sample: 텍스트 생성 모델에서 샘플링 방식을 사용할지 여부를 결정\n",
        "  - True: 다음 토큰 생성시 확률 분포에서 샘플링 해 더 다양한 텍스트 생성\n",
        "  - False: 다음 토큰 생성시 가장 높은 확률을 가진 단어 선택해 예측 가능함\n",
        "\n",
        "- top_k: top_p가 누적 확률이 p이하인 단어만 고려한다면 top_k는 상위 k개의 단어만 고려해 확률이 높은 단어만 선택하게 함(top_p는 누적 확률이므로 일부 낮은 단어도 선택할 수 있게해 더 다양함)"
      ],
      "metadata": {
        "id": "zALQZX1NCE4P"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "repo_id = '42dot/42dot_LLM-SFT-1.3B'\n",
        "\n",
        "question = \"너는 어떤 AI 모델이야?\"\n",
        "\n",
        "template = \"\"\"너는 AI 분야에 박식한 정말 도움이 되는 조수야.\n",
        "\n",
        "Question: {question}\n",
        "\n",
        "Answer: \"\"\"\n",
        "\n",
        "prompt = PromptTemplate(template=template, input_variables=[\"question\"])\n",
        "\n",
        "model_params_list = [\n",
        "    {\"temperature\": 0.2, \"max_length\": 128},  # 기본 설정\n",
        "    {\"temperature\": 0.7, \"max_length\": 128},  # 높은 온도\n",
        "    {\"temperature\": 0.2, \"max_length\": 64},   # 짧은 최대 길이\n",
        "    {\"temperature\": 0.2, \"max_length\": 256},  # 긴 최대 길이\n",
        "    {\"temperature\": 1.0, \"max_length\": 128},  # 매우 높은 온도\n",
        "    {\"temperature\": 0.2, \"max_length\": 128, \"top_p\": 0.9},  # Top-p 샘플링 추가\n",
        "    {\"temperature\": 0.2, \"max_length\": 128, \"num_beams\": 5},  # 빔 서치 추가\n",
        "    {\"temperature\": 0.2, \"max_length\": 128, \"repetition_penalty\": 1.2},  # 반복 페널티 추가\n",
        "    {\"temperature\": 0.2, \"max_length\": 128, \"length_penalty\": 0.8},  # 길이 페널티 추가\n",
        "    {\"temperature\": 0.2, \"max_length\": 128, \"no_repeat_ngram_size\": 3},  # n-gram 반복 방지\n",
        "    {\"temperature\": 0.2, \"max_length\": 128, \"early_stopping\": True},  # 조기 종료\n",
        "    {\"temperature\": 0.2, \"max_length\": 128, \"do_sample\": True, \"top_k\": 50},  # 샘플링 및 Top-k 추가\n",
        "]\n",
        "\n",
        "# 각 설정에 대해 LLMChain 생성 및 실행\n",
        "for i, model_params in enumerate(model_params_list):\n",
        "    llm = HuggingFaceHub(repo_id=repo_id, model_kwargs=model_params)\n",
        "    llm_chain = LLMChain(prompt=prompt, llm=llm)\n",
        "    print(f\"설정 {i+1}: {model_params}\")\n",
        "    print(llm_chain.run(question=question))\n",
        "    print(\"\\n\" + \"=\"*50 + \"\\n\")"
      ],
      "metadata": {
        "id": "86manosICFJ_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### 3. 복수의 질문 처리"
      ],
      "metadata": {
        "id": "p-QQrXjoIMEm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- 각 질문에 대해 LLMChain을 호출하여 답변을 얻는 코드\n",
        "TODO 구조 수정 필요"
      ],
      "metadata": {
        "id": "zZEXosF6K4HR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "repo_id = '42dot/42dot_LLM-SFT-1.3B'\n",
        "\n",
        "# 초기 대화 설정\n",
        "conversation_history = \"\"\n",
        "\n",
        "# 질문 목록\n",
        "questions = [\n",
        "    \"한국에서 요즘 가장 인기 많은 영화가 뭐야?\",\n",
        "    \"너는 무슨 영화 좋아해?\",\n",
        "    \"나는 무슨 영화 좋아하게?\",\n",
        "    \"한국 좋아해?\",\n",
        "    \"한국에서 뭘 좋아해?\"\n",
        "]\n",
        "\n",
        "# 프롬프트 템플릿\n",
        "template = \"\"\"너는 한국 문화를 좋아하지만 한국 영화에 비판적인 사고를 가졌고 나는 한국 영화 싫어하는 사람이야.\n",
        "{conversation_history}\n",
        "\n",
        "Question: {question}\n",
        "\n",
        "Answer: \"\"\"\n",
        "\n",
        "prompt = PromptTemplate(template=template, input_variables=[\"conversation_history\", \"question\"])\n",
        "\n",
        "# LLM 설정\n",
        "llm = HuggingFaceHub(\n",
        "    repo_id=repo_id,\n",
        "    model_kwargs={\"temperature\": 0.2,\n",
        "                  \"max_length\": 128}\n",
        ")\n",
        "\n",
        "# LLM 체인 설정\n",
        "llm_chain = LLMChain(prompt=prompt, llm=llm)\n",
        "\n",
        "# 각 질문에 대해 답변 생성\n",
        "for question in questions:\n",
        "    # 답변 생성\n",
        "    answer = llm_chain.run(conversation_history=conversation_history, question=question)\n",
        "\n",
        "    # 대화 문맥 업데이트\n",
        "    conversation_history += f\"\\nQuestion: {question}\\nAnswer: {answer}\"\n",
        "\n",
        "    # 출력\n",
        "    print(f\"질문: {question}\")\n",
        "    print(f\"응답: {answer}\")\n",
        "    print(\"-\" * 50)"
      ],
      "metadata": {
        "collapsed": true,
        "id": "vPyhw0IAK3lo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def get_answer(question, conversation_history):\n",
        "    \"\"\"주어진 질문과 대화 문맥을 사용하여 답변을 생성하고 반환합니다.\"\"\"\n",
        "    answer = llm_chain.run(conversation_history=conversation_history, question=question)\n",
        "    answer_lines = answer.split('\\n')\n",
        "    actual_answer = answer_lines[0] if answer_lines else answer\n",
        "    return actual_answer\n",
        "\n",
        "# 각 질문에 대해 답변 생성 및 대화 문맥 업데이트\n",
        "answers = []\n",
        "for question in questions:\n",
        "    actual_answer = get_answer(question, conversation_history)\n",
        "    conversation_history += f\"\\nQuestion: {question}\\nAnswer: {actual_answer}\"\n",
        "    answers.append((question, actual_answer))\n",
        "\n",
        "# 출력\n",
        "for question, answer in answers:\n",
        "    print(f\"질문: {question}\")\n",
        "    print(f\"응답: {answer}\")\n",
        "    print(\"-\" * 50)"
      ],
      "metadata": {
        "id": "l3lkr7muU1jD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###### 4. 복수의 모델 조합"
      ],
      "metadata": {
        "id": "TGJn8dnNIQoW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- LangChain이 인터페이스를 제공하기 때문에 세부 구현을 몰라도 다양한 LLM 사용 가능"
      ],
      "metadata": {
        "id": "AFv5R4rtVNa7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# HuggingFace Repository IDs\n",
        "repo_id_1 = '42dot/42dot_LLM-SFT-1.3B'\n",
        "repo_id_2 = 'gpt2'  # 예시로 다른 모델 사용\n",
        "\n",
        "# 질의내용\n",
        "question = \"너는 어떤 AI 모델이야?\"\n",
        "\n",
        "# 템플릿\n",
        "template = \"\"\"Question: {question}\n",
        "\n",
        "Answer: \"\"\"\n",
        "\n",
        "# 프롬프트 템플릿 생성\n",
        "prompt = PromptTemplate(template=template, input_variables=[\"question\"])\n",
        "\n",
        "# HuggingFaceHub 객체 생성\n",
        "llm_1 = HuggingFaceHub(\n",
        "    repo_id=repo_id_1,\n",
        "    model_kwargs={\"temperature\": 0.2,\n",
        "                  \"max_length\": 128}\n",
        ")\n",
        "\n",
        "llm_2 = HuggingFaceHub(\n",
        "    repo_id=repo_id_2,\n",
        "    model_kwargs={\"temperature\": 0.2,\n",
        "                  \"max_length\": 128}\n",
        ")\n",
        "\n",
        "# LLM Chain 객체 생성\n",
        "llm_chain_1 = LLMChain(prompt=prompt, llm=llm_1)\n",
        "llm_chain_2 = LLMChain(prompt=prompt, llm=llm_2)\n",
        "\n",
        "# 실행 및 결과 출력\n",
        "response_1 = llm_chain_1.run(question=question)\n",
        "response_2 = llm_chain_2.run(question=question)\n",
        "\n",
        "print(\"Response from LLM 1:\")\n",
        "print(response_1)\n",
        "print(\"\\nResponse from LLM 2:\")\n",
        "print(response_2)"
      ],
      "metadata": {
        "id": "fYuUvA34VNkS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 확장 실습 - 챗봇 만들기"
      ],
      "metadata": {
        "id": "rzvqKTL5VIqS"
      }
    }
  ]
}