RAG & LANCHAIN (3)- Langchain 개념 & 문법 정리 ch.04 모델

이영락·2024년 8월 27일

인공지능 공부

목록 보기

7/33

🏖️ CH04 모델(Model)

모델 또는 LLM(Large Language Model) 단계

모델 또는 LLM 단계는 이전 단계에서 구성된 입력을 바탕으로 대규모 언어 모델(LLM)을 활용하여 응답을 생성하는 과정이다. 이 단계는 RAG 시스템의 핵심으로, LLM을 활용해 사용자의 질문에 대해 정확하고 자연스러운 답변을 생성하는 역할을 한다.

LLM의 필요성

사용자 의도 이해: LLM은 다양한 언어의 구조와 의미를 깊이 이해하여, 복잡한 질문에도 답변할 수 있다. 자연어 이해(NLU)와 자연어 생성(NLG) 능력을 결합해 자연스럽고 유익한 응답을 제공한다.
문맥적 적응성: LLM은 주어진 문맥을 고려해 응답을 생성하며, 사용자가 제공한 정보를 바탕으로 문맥에 맞는 답변을 생성한다.

LLM의 중요성

LLM 단계는 사용자의 질문에 대한 답변의 질과 자연스러움을 결정짓는 중요한 요소이다. 이 단계에서 LLM은 모든 데이터를 종합해 최적화된 답변을 생성하며, 이는 RAG 시스템의 전체적인 성능과 사용자 만족도에 큰 영향을 미친다.

코드 예시

OpenAI GPT-4o 활용:

from langchain_openai import ChatOpenAI

# LLM 생성
llm = ChatOpenAI(model_name="gpt-4o")

Anthropic Claude3 Sonnet 활용:

from langchain_anthropic import ChatAnthropic

# LLM 생성
llm = ChatAnthropic(model="claude-3-sonnet-20240229")

로컬 모델(llama3-8b) 활용:

from langchain_community.chat_models import ChatOllama

# 로컬 LLM 생성
llm = ChatOllama(model="llama3:8b")

아래는 '01. 다양한 LLM 모델 활용' 내용을 정리한 것입니다.

🏖️ 01. 다양한 LLM 모델 활용

다양한 LLM(Large Language Model) 모델을 활용하여 자연어 처리 작업을 수행하는 방법을 알아본다. 각 모델은 특정 기능과 강점을 가지고 있으며, 다양한 환경에서 사용될 수 있다.

OpenAI

OpenAI의 채팅 전용 LLM으로, GPT-4o를 포함한 여러 모델이 있다. 모델 생성 시 온도(temperature), 최대 토큰 수(max_tokens) 등의 옵션을 지정할 수 있으며, 각 모델은 고유한 특징을 가지고 있다.

예시 코드:

from langchain_openai import ChatOpenAI

# ChatOpenAI 객체 생성
gpt = ChatOpenAI(
    temperature=0,
    model_name="gpt-4o",  # 모델명
)

# 스트리밍 출력
answer = gpt.stream("사랑이 뭔가요?")
stream_response(answer)

ChatAnthropic

Anthropic의 Claude 시리즈는 AI 안전성과 연구에 중점을 둔 LLM이다. Claude 모델은 API를 통해 쉽게 접근할 수 있으며, 다양한 사용 사례에 적용 가능하다.

예시 코드:

from langchain_anthropic import ChatAnthropic

# ChatAnthropic 객체 생성
anthropic = ChatAnthropic(model_name="claude-3-5-sonnet-20240620")

# 스트리밍 출력
answer = anthropic.stream("사랑이 뭔가요?")
stream_response(answer)

ChatCohere

Cohere는 기업용 AI 솔루션을 제공하는 선도적인 AI 기업으로, Command R+와 같은 모델을 통해 복잡한 비즈니스 프로세스를 자동화하는 데 최적화되어 있다.

예시 코드:

from langchain_cohere import ChatCohere

# ChatCohere 객체 생성
cohere = ChatCohere(temperature=0)

# 스트리밍 출력
answer = cohere.stream("사랑이 뭔가요?")
stream_response(answer)

ChatUpstage

Upstage는 한국의 AI 스타트업으로, Solar LLM과 같은 모델을 통해 문서 AI와 개인화된 검색 및 추천 서비스를 제공한다.

예시 코드:

from langchain_upstage import ChatUpstage

# ChatUpstage 객체 생성
upstage = ChatUpstage()

# 스트리밍 출력
answer = upstage.stream("사랑이 뭔가요?")
stream_response(answer)

Xionic

사이오닉에이아이(Sionic AI)는 한국어 AI 모델을 개발하는 스타트업으로, 상업적 이용이 가능한 라이센스를 제공하는 Xionic 모델을 통해 기업용 생성형 AI 솔루션을 지원한다.

예시 코드:

from langchain_openai import ChatOpenAI

# Xionic 객체 생성
xionic = ChatOpenAI(
    model_name="xionic-1-72b-20240610",
    base_url="https://sionic.chat/v1/",
    api_key="934c4bbc-c384-4bea-af82-1450d7f8128d",
)

# 스트리밍 출력
answer = xionic.stream("사랑이 뭔가요?")
stream_response(answer)

LogicKor

LogicKor는 한국어 언어 모델의 사고력을 평가하는 벤치마크 리더보드로, 다양한 모델의 성능을 비교하고 객관적인 지표를 제공하는 중요한 도구이다.

아래는 '02. 캐싱(Cache)' 내용을 정리한 것입니다.

🏖️ 02. 캐싱(Cache)

캐싱(Caching)의 필요성

캐싱(Caching)은 LangChain에서 LLM을 사용할 때, 동일한 요청에 대해 반복적으로 API 호출을 줄이기 위해 사용되는 선택적 캐싱 레이어이다. 이를 통해 비용을 절감하고 애플리케이션의 속도를 높일 수 있다.

모델과 프롬프트 생성

먼저, 사용하려는 LLM 모델과 프롬프트를 생성한다.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import PromptTemplate

# 모델을 생성합니다.
llm = ChatOpenAI(model_name="gpt-3.5-turbo")

# 프롬프트를 생성합니다.
prompt = PromptTemplate.from_template("{country} 에 대해서 200자 내외로 요약해줘")

# 체인을 생성합니다.
chain = prompt | llm

InMemoryCache 사용

InMemoryCache는 메모리에 데이터를 저장하여 동일한 요청에 대한 응답을 캐시하고, 저장된 응답을 반환한다.

from langchain.globals import set_llm_cache
from langchain.cache import InMemoryCache

# 인메모리 캐시를 사용합니다.
set_llm_cache(InMemoryCache())

# 체인을 실행하여 응답을 캐싱합니다.
response = chain.invoke({"country": "한국"})
print(response.content)

응답이 캐시에 저장된 후 동일한 요청에 대해 캐시된 응답이 반환되며, 처리 시간이 크게 단축된다.

SQLiteCache 사용

SQLiteCache는 SQLite 데이터베이스를 사용하여 응답을 캐싱하는 방식이다. 이 방법은 캐시 데이터를 파일로 저장하므로, 애플리케이션을 재시작해도 캐시가 유지된다.

from langchain_community.cache import SQLiteCache
from langchain_core.globals import set_llm_cache
import os

# 캐시 디렉토리 생성
if not os.path.exists("cache"):
    os.makedirs("cache")

# SQLiteCache를 사용합니다.
set_llm_cache(SQLiteCache(database_path="cache/llm_cache.db"))

# 체인을 실행하여 응답을 캐싱합니다.
response = chain.invoke({"country": "한국"})
print(response.content)

SQLite 캐시를 사용하면 응답이 데이터베이스에 저장되고, 이후 동일한 요청에 대해 데이터베이스에서 캐시된 응답이 반환된다.

아래는 '03. 모델 직렬화(Serialization) - 저장 및 불러오기' 내용을 정리한 것입니다.

🏖️ 03. 모델 직렬화(Serialization) - 저장 및 불러오기

직렬화(Serialization)란?

직렬화(Serialization)는 모델을 저장 가능한 형식으로 변환하는 과정이다. 이를 통해 모델을 재사용하거나 배포, 공유할 수 있으며, 계산 리소스를 절약하는 등의 이점을 제공한다.

직렬화의 목적과 장점

모델 재사용: 재훈련 없이 모델을 재사용할 수 있다.
모델 배포 및 공유: 직렬화된 모델은 쉽게 배포하고 공유할 수 있다.
계산 리소스 절약: 모델을 다시 로드할 때 시간이 절약된다.
빠른 모델 로딩: 저장된 상태에서 모델을 빠르게 로딩할 수 있다.
버전 관리 가능: 모델의 버전을 관리할 수 있다.
다양한 환경에서 사용 가능: 직렬화된 모델은 다양한 환경에서 쉽게 사용할 수 있다.

직렬화 가능 여부 확인

is_lc_serializable 클래스 메서드를 사용하여 LangChain 클래스가 직렬화 가능한지 확인할 수 있다.

from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate

# 프롬프트 템플릿 생성
prompt = PromptTemplate.from_template("{fruit}의 색상이 무엇입니까?")

# 모델 직렬화 가능 여부 확인
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
print(f"ChatOpenAI: {llm.is_lc_serializable()}")
# 출력: ChatOpenAI: True

# 체인 생성 및 직렬화 가능 여부 확인
chain = prompt | llm
print(chain.is_lc_serializable())  # 출력: True

체인(Chain) 직렬화

체인을 직렬화하여 저장할 수 있으며, dumps와 dumpd 함수를 사용해 JSON 문자열 또는 딕셔너리 형식으로 변환할 수 있다.

from langchain_core.load import dumpd, dumps

# 체인 직렬화
dumpd_chain = dumpd(chain)
print(type(dumpd_chain))  # 출력: <class 'dict'>

dumps_chain = dumps(chain)
print(type(dumps_chain))  # 출력: <class 'str'>

Pickle 파일로 저장

Pickle은 Python 객체를 바이너리 형태로 직렬화하는 포맷으로, 효율적인 저장 및 전송, 복잡한 객체 구조를 유지하는 데 적합하다.

import pickle

# Pickle 파일로 직렬화된 체인 저장
with open("fruit_chain.pkl", "wb") as f:
    pickle.dump(dumpd_chain, f)

JSON 형식으로 저장

직렬화된 체인은 JSON 형식으로도 저장할 수 있다.

import json

with open("fruit_chain.json", "w") as fp:
    json.dump(dumpd_chain, fp)

저장한 모델 불러오기

저장한 Pickle 또는 JSON 파일을 불러와 체인을 복원할 수 있다.

import pickle
from langchain_core.load import load

# Pickle 파일 불러오기
with open("fruit_chain.pkl", "rb") as f:
    loaded_chain = pickle.load(f)

# 체인 로드 및 실행
chain_from_file = load(loaded_chain)
print(chain_from_file.invoke({"fruit": "사과"}))

JSON 파일을 불러올 때도 동일한 방식으로 작업할 수 있다.

with open("fruit_chain.json", "r") as fp:
    loaded_from_json_chain = json.load(fp)
    loads_chain = load(loaded_from_json_chain)

print(loads_chain.invoke({"fruit": "사과"}))

아래는 '04. 토큰 사용량 확인' 내용을 정리한 것입니다.

🏖️ 04. 토큰 사용량 확인

토큰 사용량 추적의 필요성

토큰 사용량을 추적하는 것은 LLM(특히 OpenAI API)을 사용할 때 매우 중요하다. 이를 통해 API 호출에 소요된 비용을 모니터링하고, 효율적으로 예산을 관리할 수 있다.

토큰 사용량 추적 방법

OpenAI API에서는 특정 호출에 대한 토큰 사용량을 추적할 수 있는 기능이 제공된다. 이 기능을 활용해 모델의 프롬프트와 응답에 사용된 토큰 수를 확인할 수 있다.

단일 호출에 대한 토큰 사용량 추적

아래는 단일 ChatOpenAI 모델 호출에 대한 토큰 사용량을 추적하는 간단한 예시이다.

from langchain.callbacks import get_openai_callback
from langchain_openai import ChatOpenAI

# 모델을 불러옵니다.
llm = ChatOpenAI(model_name="gpt-4o")

# callback을 사용하여 토큰 사용량을 추적합니다.
with get_openai_callback() as cb:
    result = llm.invoke("대한민국의 수도는 어디야?")
    print(cb)

출력 예시:

Tokens Used: 55
Prompt Tokens: 15
Completion Tokens: 40
Successful Requests: 1
Total Cost (USD): $0.000675

여러 호출에 대한 토큰 사용량 추적

여러 번의 호출에 대한 토큰 사용량을 추적하는 방법은 아래와 같다.

# 여러 호출에 대해 토큰 사용량을 추적합니다.
with get_openai_callback() as cb:
    result = llm.invoke("대한민국의 수도는 어디야?")
    result = llm.invoke("대한민국의 수도는 어디야?")
    
    print(f"총 사용된 토큰수: \t\t{cb.total_tokens}")
    print(f"프롬프트에 사용된 토큰수: \t{cb.prompt_tokens}")
    print(f"답변에 사용된 토큰수: \t{cb.completion_tokens}")
    print(f"호출에 청구된 금액(USD): \t${cb.total_cost}")

출력 예시:

총 사용된 토큰수:      98
프롬프트에 사용된 토큰수:  30
답변에 사용된 토큰수:    68
호출에 청구된 금액(USD):    $0.00117

아래는 '05. 구글 생성 AI(Google Generative AI)' 내용을 정리한 것입니다.

🏖️ 05. 구글 생성 AI(Google Generative AI)

Google Generative AI 개요

Google Generative AI는 Google의 Gemini 및 Gemini-Vision 모델을 포함한 다양한 생성 AI 모델에 접근할 수 있는 기능을 제공한다. 이를 통해 고급 대화형 AI 시스템을 구현할 수 있다.

API 사용 준비

API KEY 발급: API KEY 발급 링크에서 API 키를 발급받아, 환경 변수 GOOGLE_API_KEY로 설정한다.
LangChain Google GenAI 통합 패키지 설치: langchain-google-genai 패키지를 설치한다.

!pip install -qU langchain-google-genai

Google Generative AI 모델 사용 예시

ChatGoogleGenerativeAI 클래스를 사용하여 Google의 대화형 AI 모델과 상호작용할 수 있다.

from langchain_google_genai import ChatGoogleGenerativeAI

# ChatGoogleGenerativeAI 언어 모델을 초기화합니다.
llm = ChatGoogleGenerativeAI(model="gemini-1.5-pro-latest")

# 프롬프트를 전달하여 결과를 생성합니다.
answer = llm.stream("자연어처리에 대해서 간략히 설명해 줘")

# 결과를 출력합니다.
stream_response(answer)

Safety Settings

Gemini 모델에는 기본 안전 설정이 포함되어 있으며, 이를 재정의할 수 있다. 이 설정은 생성된 콘텐츠의 안전성과 적절성을 보장하는 데 도움을 준다.

from langchain_google_genai import (
    ChatGoogleGenerativeAI,
    HarmBlockThreshold,
    HarmCategory,
)

llm = ChatGoogleGenerativeAI(
    model="gemini-1.5-pro-latest",
    safety_settings={
        HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
        HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
        HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
    },
)

Batch 단위 실행

Batch 단위로 여러 요청을 한 번에 처리할 수 있다.

llm = ChatGoogleGenerativeAI(model="gemini-1.5-pro-latest")

results = llm.batch([
    "대한민국의 수도는?",
    "대한민국의 주요 관광지 5곳을 나열하세요",
])

for res in results:
    print(res.content)

Multimodal 모델 활용

Multimodal 모델을 사용하여 텍스트와 이미지를 결합한 응답을 생성할 수 있다.

from langchain_teddynote.models import MultiModal
from langchain_teddynote.messages import stream_response

# 멀티모달 객체 생성
gemini = ChatGoogleGenerativeAI(model="gemini-1.5-pro-latest")

system_prompt = "당신은 시인입니다. 당신의 임무는 주어진 이미지를 가지고 시를 작성하는 것입니다."
user_prompt = "다음의 이미지에 대한 시를 작성해주세요."

multimodal_gemini = MultiModal(
    gemini, system_prompt=system_prompt, user_prompt=user_prompt
)

IMAGE_URL = "images/jeju-beach.jpg"

# 이미지 파일로 부터 질의
answer = multimodal_gemini.stream(IMAGE_URL)

# 스트리밍 방식으로 각 토큰을 출력합니다.
stream_response(answer)

예시 출력:

하늘빛 거울에 비친 섬 하나
고요한 평화 속에 잠든 듯
푸른 장막 드리운 채 누워있네
...

아래는 '06. 허깅페이스 엔드포인트(HuggingFace Endpoints)' 내용을 정리한 것입니다.

🏖️ 06. 허깅페이스 엔드포인트(HuggingFace Endpoints)

Hugging Face Hub 개요

Hugging Face Hub는 12만 개 이상의 모델과 2만 개의 데이터셋, 5만 개의 데모 앱(Spaces)을 제공하는 플랫폼으로, 이를 통해 머신러닝을 쉽게 구축하고 협업할 수 있다. Hugging Face Hub은 다양한 머신러닝 애플리케이션을 위한 여러 엔드포인트를 제공하며, 특히 텍스트 생성 추론(Text Generation Inference)을 위해 최적화된 환경을 제공한다.

허깅페이스 토큰 발급 및 설치

허깅페이스 토큰 발급: Hugging Face 토큰 발급 페이지에서 토큰을 발급받아 .env 파일에 HUGGINGFACEHUB_API_TOKEN으로 저장한다.
필요한 패키지 설치: huggingface_hub 패키지를 설치한다.

!pip install -qU huggingface_hub

HuggingFace Endpoint 설정

from dotenv import load_dotenv
from huggingface_hub import login
from langchain_core.output_parsers import StrOutputParser
from langchain_huggingface import HuggingFaceEndpoint
import os

# 환경 변수 로드
load_dotenv()

# Hugging Face 로그인
login()

# 사용할 모델의 저장소 ID를 설정합니다.
repo_id = "microsoft/Phi-3-mini-4k-instruct"

# HuggingFaceEndpoint 초기화
llm = HuggingFaceEndpoint(
    repo_id=repo_id,  # 모델 저장소 ID 지정
    max_new_tokens=256,  # 생성할 최대 토큰 길이 설정
    temperature=0.1,
    huggingfacehub_api_token=os.environ["HUGGINGFACEHUB_API_TOKEN"],  # 허깅페이스 토큰
)

# 프롬프트를 생성하여 실행
from langchain.prompts import PromptTemplate

template = """<|system|>
You are a helpful assistant.<|end|>
<|user|>
{question}<|end|>
<|assistant|>"""
prompt = PromptTemplate.from_template(template)

# LLMChain을 초기화하고 실행
chain = prompt | llm | StrOutputParser()
response = chain.invoke({"question": "what is the capital of South Korea?"})

print(response)

전용 엔드포인트(Dedicated Endpoint)

Hugging Face는 무료 서버리스 API와 더불어, 프로덕션 환경을 위한 전용 Inference Endpoints를 제공한다. 이 엔드포인트는 고성능과 유연성을 제공하며, 자동 확장과 같은 기능을 포함한다.

# Inference Endpoint URL 설정
hf_endpoint_url = "https://slcalzucia3n7y3g.us-east-1.aws.endpoints.huggingface.cloud"

# HuggingFaceEndpoint 초기화
llm = HuggingFaceEndpoint(
    endpoint_url=hf_endpoint_url,
    max_new_tokens=512,
    temperature=0.01,
)

# 모델 실행
response = llm.invoke(input="대한민국의 수도는 어디인가요?")
print(response)

Serverless Endpoints

Inference API는 무료로 사용할 수 있으며, 요금 제한이 있다. 대규모 사용 사례에서는 로드가 다른 요청과 공유되기 때문에 속도 제한이 있을 수 있다. 이러한 경우 전용 엔드포인트를 사용하는 것이 좋다.

Batch 단위 실행

Batch 단위로 여러 요청을 한 번에 처리할 수 있다.

llm = HuggingFaceEndpoint(model="microsoft/Phi-3-mini-4k-instruct")

results = llm.batch([
    "대한민국의 수도는?",
    "대한민국의 주요 관광지 5곳을 나열하세요",
])

for res in results:
    print(res.content)

예시 출력:

대한민국의 수도는 서울입니다.
대한민국의 주요 관광지 5곳 (다양한 분야에서 선정):
1. 경주 역사유적지구
2. 제주도
3. 서울특별시
4. 부산광역시
5. DMZ 및 판문점

아래는 '07. 허깅페이스 로컬(HuggingFace Local)' 내용을 정리한 것입니다.

🏖️ 07. 허깅페이스 로컬(HuggingFace Local)

Hugging Face 로컬 모델 사용 개요

Hugging Face Local을 통해 로컬 환경에서 모델을 다운로드하고 실행할 수 있다. 이 방법은 인터넷 연결 없이도 모델을 사용하거나, 데이터를 로컬 환경에서 처리해야 하는 경우 유용하다.

환경 설정

환경 변수 설정: Hugging Face 모델과 토크나이저를 다운로드할 경로를 설정한다. 이를 통해 모델과 관련 파일들이 특정 디렉토리에 저장된다.

import os

# 다운로드 경로 설정
os.environ["TRANSFORMERS_CACHE"] = "./cache/"
os.environ["HF_HOME"] = "./cache/"

Hugging Face 모델 로컬 다운로드 및 실행

HuggingFacePipeline 클래스를 사용하여 로컬 모델을 설정하고 텍스트 생성을 수행할 수 있다.

from langchain_huggingface import HuggingFacePipeline

# 모델 설정
llm = HuggingFacePipeline.from_model_id(
    model_id="microsoft/Phi-3-mini-4k-instruct",
    task="text-generation",
    pipeline_kwargs={
        "max_new_tokens": 256,
        "top_k": 50,
        "temperature": 0.1,
    },
)

# 모델 실행
response = llm.invoke("Hugging Face is")
print(response)

출력 예시:

'Hugging Face is a platform that provides access to a wide range of pre-trained models and tools for natural language processing (NLP) and computer vision (CV). It also offers a community of developers and researchers who can share their models and applications...'

프롬프트 생성 및 체인 실행

프롬프트 템플릿을 사용하여 입력 텍스트를 기반으로 중요한 포인트를 요약하는 체인을 생성하고 실행할 수 있다.

from langchain_core.prompts import PromptTemplate

# 프롬프트 템플릿 생성
template = """Summarizes TEXT in simple bullet points ordered from most important to least important.
TEXT:
{text}

KeyPoints: """
prompt = PromptTemplate.from_template(template)

# 체인 생성
chain = prompt | llm

# 입력 텍스트
text = """A Large Language Model (LLM) like me, ChatGPT, is a type of artificial intelligence..."""

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

# 결과 출력
print(response)

출력 예시:

KeyPoints: 
- LLMs are AI models that understand, generate, and interact with human language.
- They are "large" due to their vast amounts of text data and billions or trillions of parameters.
- LLMs predict the next word in a sequence to generate coherent and contextually relevant text.
- ...

Hugging Face 로컬 모델의 장점

네트워크 의존성 감소: 로컬 환경에서 모델을 다운로드 및 실행할 수 있어 네트워크 연결 없이도 사용 가능.
데이터 보안: 민감한 데이터를 로컬에서 처리할 수 있어 데이터 유출 위험이 적음.
성능 최적화: 로컬 시스템의 리소스를 활용하여 성능을 최적화할 수 있음.

아래는 '08. 허깅페이스 파이프라인(HuggingFace Pipeline)'에 대한 내용을 정리한 것입니다.

🏖️ 08. 허깅페이스 파이프라인(HuggingFace Pipeline)

Hugging Face Local Pipelines

HuggingFacePipeline 클래스를 통해 로컬 환경에서 Hugging Face 모델을 실행할 수 있습니다. Hugging Face는 12만 개 이상의 모델을 호스팅하며, 이를 통해 다양한 머신러닝 애플리케이션을 구축할 수 있습니다.

환경 설정

환경 변수 설정: Hugging Face 모델과 토크나이저를 다운로드할 경로를 설정합니다.

import os

# 다운로드 경로 설정
os.environ["TRANSFORMERS_CACHE"] = "./cache/"
os.environ["HF_HOME"] = "./cache/"

모델 로드 및 텍스트 생성

HuggingFacePipeline 클래스를 사용하여 로컬에서 모델을 로드하고 텍스트 생성을 수행할 수 있습니다.

from langchain_community.llms.huggingface_pipeline import HuggingFacePipeline

# HuggingFace 모델 로드
hf = HuggingFacePipeline.from_model_id(
    model_id="beomi/llama-2-ko-7b",  # 사용할 모델의 ID
    task="text-generation",  # 수행할 작업
    pipeline_kwargs={"max_new_tokens": 512},  # 추가 인자
)

# 텍스트 생성
response = hf.invoke("Hugging Face is")
print(response)

기존 파이프라인 사용

기존 transformers 파이프라인을 직접 전달하여 모델을 로드할 수도 있습니다.

from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline

model_id = "beomi/llama-2-ko-7b"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)

pipe = pipeline("text-generation", model=model, tokenizer=tokenizer, max_new_tokens=512)
hf = HuggingFacePipeline(pipeline=pipe)

# 텍스트 생성 실행
response = hf.invoke("Explain the benefits of using Hugging Face.")
print(response)

체인 생성 및 실행

모델이 메모리에 로드되면, PromptTemplate과 결합하여 체인을 생성할 수 있습니다.

from langchain.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser

template = """Answer the following question in Korean.
#Question: 
{question}

#Answer: """
prompt = PromptTemplate.from_template(template)

# 체인 생성
chain = prompt | hf | StrOutputParser()

# 질문 실행
question = "대한민국의 수도는 어디야?"
print(chain.invoke({"question": question}))

GPU에서 모델 실행

모델을 GPU에서 실행하려면 device 매개변수를 설정합니다.

gpu_llm = HuggingFacePipeline.from_model_id(
    model_id="beomi/llama-2-ko-7b",
    task="text-generation",
    device=0,  # GPU 번호
    pipeline_kwargs={"max_new_tokens": 64},
)

gpu_chain = prompt | gpu_llm | StrOutputParser()

# GPU에서 실행
question = "대한민국의 수도는 어디야?"
print(gpu_chain.invoke({"question": question}))

배치 모드 실행

GPU에서 배치 모드로 여러 개의 질문을 병렬로 처리할 수 있습니다.

gpu_llm = HuggingFacePipeline.from_model_id(
    model_id="beomi/llama-2-ko-7b",
    task="text-generation",
    device=0,
    batch_size=2,
    model_kwargs={"temperature": 0, "max_length": 256},
)

gpu_chain = prompt | gpu_llm.bind(stop=["\n\n"])

questions = [{"question": f"숫자 {i} 이 한글로 뭐에요?"} for i in range(4)]

answers = gpu_chain.batch(questions)
for answer in answers:
    print(answer)

아래는 '09. 올라마(Ollama)'에 대한 내용을 정리한 것입니다.

🏝️ 09. 올라마(Ollama)

Ollama 개요

Ollama를 사용하면 Llama 3와 같은 오픈 소스 대규모 언어 모델(LLM)을 로컬에서 실행할 수 있습니다. Ollama는 모델 가중치, 구성, 데이터를 하나의 패키지로 번들링하며, GPU 사용을 포함한 최적화된 설정을 제공합니다. Ollama는 Mac, Linux, Windows 플랫폼을 지원합니다.

설치

Ollama 설치: Ollama는 공식 웹사이트(https://ollama.com)에서 다운로드 및 설치할 수 있습니다.
모델 다운로드: Hugging Face에서 제공되는 GGUF 확장자의 모델 또는 Ollama가 제공하는 모델을 다운로드할 수 있습니다.
- 예: ollama pull gemma:7b 명령어를 사용하여 LLM 모델을 가져올 수 있습니다.
Modelfile 생성: 모델을 임포트하려면 먼저 Modelfile을 생성해야 합니다.

Ollama 모델 사용

명령줄 인터페이스: 명령어 ollama run <name-of-model>을 통해 모델과 직접 상호 작용할 수 있습니다.
LangChain과의 통합: LangChain을 사용하여 Ollama 모델을 간편하게 사용할 수 있습니다.

LangChain + Ollama 사용법

from langchain_community.chat_models import ChatOllama
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_teddynote.messages import stream_response

# Ollama 모델 불러오기
llm = ChatOllama(model="EEVE-Korean-10.8B:latest")

# 프롬프트 정의
prompt = ChatPromptTemplate.from_template("{topic} 에 대하여 간략히 설명해 줘.")

# 체인 생성
chain = prompt | llm | StrOutputParser()

# 주제에 대한 간략한 설명을 요청
answer = chain.stream({"topic": "deep learning"})

# 스트리밍 출력
stream_response(answer)

비동기 스트리밍 지원

비동기 스트리밍을 통해 청크 단위로 결과를 실시간으로 처리할 수 있습니다.

async for chunks in chain.astream({"topic": "구글"}):
    print(chunks, end="", flush=True)

JSON 형식의 응답

Ollama의 최신 버전을 사용하여 JSON 형식으로 응답을 생성할 수 있습니다.

llm = ChatOllama(
    model="gemma:7b",
    format="json",  # JSON 형식으로 설정
    temperature=0,
)

# JSON 응답 요구 프롬프트
prompt = "유럽 여행지 10곳을 알려주세요. key: `places`. response in JSON format."

# 체인 실행
response = llm.invoke(prompt)
print(response.content)

멀티모달(Multimodal) 지원

Ollama는 멀티모달 모델도 지원하며, 텍스트뿐만 아니라 이미지도 처리할 수 있습니다.

from PIL import Image
from langchain_core.messages import HumanMessage
from langchain_community.chat_models import ChatOllama
from langchain_core.output_parsers import StrOutputParser

# 멀티모달 Ollama 모델 불러오기
llm = ChatOllama(model="llava:7b", temperature=0)

# 텍스트와 이미지 데이터를 함께 전달하여 쿼리 실행
query_chain = chain.invoke({"text": "Describe a picture in bullet points", "image": image_b64})

print(query_chain)

10. GPT4ALL

GPT4All은 코드, 채팅 형식의 대화 등 방대한 양의 데이터로 학습된 오픈 소스 챗봇 생태계입니다. GitHub의 nomic-ai/gpt4all에서 제공하는 이 프로젝트는 다양한 자연어 처리 작업에 활용할 수 있는 대규모 언어 모델을 제공합니다.

1. 설치 방법

1) 프로그램 설치

공식 홈페이지에서 설치 파일을 다운로드하여 설치합니다. 공식 홈페이지 바로가기

2) 파이썬 패키지 설치

파이썬 패키지를 설치하려면 다음 명령어를 사용하세요:
```
pip install -qU gpt4all
```

2. 모델 다운로드

1) 모델 선택

GPT4All 페이지에서 원하는 모델을 선택하여 다운로드하세요. 예를 들어, 이 튜토리얼에서는 EEVE-Korean-Instruct-10.8B-v1.0-Q8_0.gguf 모델을 다운로드하여 사용합니다.

2) 모델 저장

다운로드한 모델은 models 폴더를 생성한 후, 해당 폴더에 저장합니다.

예시:

local_path = "./models/EEVE-Korean-Instruct-10.8B-v1.0-Q8_0.gguf"

3. GPT4ALL 모델 활용

GPT4All을 사용하여 다양한 자연어 처리 작업을 수행할 수 있습니다. 예를 들어, 다음과 같이 GPT4All 모델을 로드하고 사용해보세요.

1) 코드 예제

from langchain.prompts import ChatPromptTemplate
from langchain_community.llms import GPT4All
from langchain_core.output_parsers import StrOutputParser
from langchain_core.callbacks import StreamingStdOutCallbackHandler

# 프롬프트 설정
prompt = ChatPromptTemplate.from_template(
    """<s>A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions.</s>
    <s>Human: {question}</s>
    <s>Assistant:
    """
)

# GPT4All 모델 초기화
llm = GPT4All(
    model=local_path,  # 모델 파일 경로
    backend="gpu",  # GPU 설정
    streaming=True,  # 스트리밍 설정
    callbacks=[StreamingStdOutCallbackHandler()],  # 콜백 설정
)

# 체인 생성
chain = prompt | llm | StrOutputParser()

# 질의 실행
response = chain.invoke({"question": "대한민국의 수도는 어디인가요?"})

print(response)

2) 실행 결과

위의 코드를 실행하면 대한민국의 수도에 대한 답변이 생성됩니다. 예:

대한민국(South Korea)의 수도는 서울입니다.

서울은 약 1000만 명의 인구를 가진 대도시로, 한반도 북부에 위치해 있습니다. 세계에서 가장 큰 도시 중 하나로 간주되며 문화, 경제 및 정치 중심지 역할을 하고 있습니다. 도시의 역사는 삼한 시대까지 거슬러 올라가며 이후 백제, 고려 그리고 조선 시대에 중요한 지역으로 발전했습니다.

서울은 다양한 박물관, 궁전, 사원 등 풍부한 문화적 유산을 자랑합니다. 주요 관광 명소로는 경복궁(Gyeongbokgung Palace), 창덕궁(Changdeokgung Palace) 및 덕수궁(Deoksugung Palace)이 있습니다.

서울은 또한 번성하는 경제를 가지고 있으며, 많은 다국적 기업들이 본사를 두고 있는 곳입니다. 도시는 기술 산업으로 유명하며 삼성전자와 LG전자와 같은 주요 기업을 보유하고 있습니다.

전반적으로 서울은 방문하기에 활기차고 흥미로운 장소입니다. 역사적인 명소부터 현대 건축물까지 모든 것을 찾을 수 있으며, 도시의 에너지와 다양성은 전 세계 여행자들을 끌어들입니다.

이영락

AI Engineer / 의료인공지능

이전 포스트

RAG & LANCHAIN (3)- Langchain 개념 & 문법 정리 ch.03 출력 파서(Output Parsers)

다음 포스트

RAG & LANCHAIN (3)- Langchain 개념 & 문법 정리 ch.04 모델

인공지능 공부

🏖️ CH04 모델(Model)

모델 또는 LLM(Large Language Model) 단계

LLM의 필요성

LLM의 중요성

코드 예시

🏖️ 01. 다양한 LLM 모델 활용

OpenAI

ChatAnthropic

ChatCohere

ChatUpstage

Xionic

LogicKor

🏖️ 02. 캐싱(Cache)

캐싱(Caching)의 필요성

모델과 프롬프트 생성

InMemoryCache 사용

SQLiteCache 사용

🏖️ 03. 모델 직렬화(Serialization) - 저장 및 불러오기

직렬화(Serialization)란?

직렬화의 목적과 장점

직렬화 가능 여부 확인

체인(Chain) 직렬화

Pickle 파일로 저장

JSON 형식으로 저장

저장한 모델 불러오기

🏖️ 04. 토큰 사용량 확인

토큰 사용량 추적의 필요성

토큰 사용량 추적 방법

단일 호출에 대한 토큰 사용량 추적

여러 호출에 대한 토큰 사용량 추적

🏖️ 05. 구글 생성 AI(Google Generative AI)

Google Generative AI 개요

API 사용 준비

Google Generative AI 모델 사용 예시

Safety Settings

Batch 단위 실행

Multimodal 모델 활용

🏖️ 06. 허깅페이스 엔드포인트(HuggingFace Endpoints)

Hugging Face Hub 개요

허깅페이스 토큰 발급 및 설치

HuggingFace Endpoint 설정

전용 엔드포인트(Dedicated Endpoint)

Serverless Endpoints

Batch 단위 실행

🏖️ 07. 허깅페이스 로컬(HuggingFace Local)

Hugging Face 로컬 모델 사용 개요

환경 설정

Hugging Face 모델 로컬 다운로드 및 실행

프롬프트 생성 및 체인 실행

Hugging Face 로컬 모델의 장점

🏖️ 08. 허깅페이스 파이프라인(HuggingFace Pipeline)

Hugging Face Local Pipelines

환경 설정

모델 로드 및 텍스트 생성

기존 파이프라인 사용

체인 생성 및 실행

GPU에서 모델 실행

배치 모드 실행

🏝️ 09. 올라마(Ollama)

Ollama 개요

설치

Ollama 모델 사용

LangChain + Ollama 사용법

비동기 스트리밍 지원

JSON 형식의 응답

멀티모달(Multimodal) 지원

10. GPT4ALL

1. 설치 방법

2. 모델 다운로드

3. GPT4ALL 모델 활용

RAG & LANCHAIN (3)- Langchain 개념 & 문법 정리 ch.03 출력 파서(Output Parsers)

RAG & LANCHAIN (4)- Langchain 기본 과정 및 기본 구조

0개의 댓글

관련 채용 정보