컴공누나의 지식 보관소

RAG Retrieval 단계 Langchain Document loaders 종류 알아보기

컴공누나 — Mon, 7 Apr 2025 22:24:11 +0900

앞의 포스팅에서 RAG가 무엇인지에 대해 알아봤는데요.

이번 포스팅에서는 RAG를 만들기 위한 재료를 어떻게 가져오는지 알아볼게요!

그 재료를 가져오는 것을 바로 Document Loader라고 부릅니다.

하나씩 자세히 알아볼게요!

혹시나 RAG 전반적인 개념이 궁금하시면 아래 포스팅 참고해주세요!

RAG(Retrieval-Augmented Generation) 기본 개념 정리 및 Langchain코드 예제

최근 ChatGPT의 등장으로 LLM에 대한 관심이 커지고 있습니다.하지만 써보신 분들은 아시겠지만, 분명히 LLM도 한계점이 존재합니다.예를 들어,최신 정보 반영이 안되어 있다거나,특정 기업 내에서

jaeyoon-95.tistory.com

Document Loader란?

RAG시스템을 구축 할 때, 참고할 데이터를 가져오는(로드하는) 로더라고 할 수 있습니다. 먼저 가져온 뒤에 LLM이 이해할 수 있도록 변환하는 과정이 필요합니다.

예를 들어,

PDF 파일을 읽어 LLM이 알아들을 수 있는 텍스트로 바꿔준다.
웹페이지 HTML 코드를 제거하고 의미있는 텍스트로 바꿔준다.

등으로 로드할 수 있겠습니다.

그럼 이런 로드는 어떻게 해야할까요?

저번 포스팅에서도 말씀드렸듯이, 아주 편한 우리의 LLM라이브러리인 Langchain이 많은 로더를 제공해줍니다.

아래에서 어느 형식의 파일을 읽어올 수 있는지 모두 알아볼게요!

Document Loader 종류

설명에 앞서 만약 실행을 하고싶으시다면, Langchain을 먼저 설치해주세요!

pip install langchain

1.TextLoader

텍스트 로더로 .txt파일을 불러올 수 있습니다.

from langchain_community.document_loaders import TextLoader

loader = TextLoader("example.txt")
documents = loader.load()

2. CSVLoader

csv형태의 데이터를 로드하여 각 행을 문서로 변환합니다.

from langchain_community.document_loaders import CSVLoader

loader = CSVLoader("example.csv")
documents = loader.load()

여기서 csv형태 뿐만 아니라 tsv도 가능합니다. 아래처럼 조건을 추가해주면 됩니다.

마치 pandas로 tsv, csv를 불러올 때와 유사하죠?

from langchain_community.document_loaders import CSVLoader

loader = CSVLoader(
    file_path="example.tsv",
    csv_args={
        "delimiter": "\t"
    }
)
documents = loader.load()

delimiter만 바꾼다면 ;나 *로 구분된 파일도 가능합니다.

3.JSONLoader

JSON 형태의 파일을 로드합니다.

from langchain_community.document_loaders import JSONLoader

loader = JSONLoader("example.json")
documents = loader.load()

4.Markdown

Markdown형태의 파일을 로드합니다.

from langchain_community.document_loaders import UnstructuredMarkdownLoader

loader = UnstructuredMarkdownLoader("example.md")
documents = loader.load()

5.PyPDFLoader

PDF문서를 페이지 단위로 로드합니다.

from langchain_community.document_loaders import PyPDFLoader

loader = PyPDFLoader("example.pdf")
documents = loader.load()

6.WebBaseLoader

웹페이지 내에 있는 HTML 콘텐츠를 로드하고, 본문에 텍스트를 추출합니다.

from langchain_community.document_loaders import WebBaseLoader

loader = WebBaseLoader("https://example.com")
documents = loader.load()

7.Sitemap

웹사이트의 Sitemap을 분석하여 여러 페이지를 자동으로 크롤링하고 로드합니다.

from langchain_community.document_loaders import SitemapLoader

loader = SitemapLoader("https://example.com/sitemap.xml")
documents = loader.load()

8.RecursiveUrlLoader

주어진 URL에서 시작하여 내부 링크를 따라가며 재귀적으로 페이지를 로드합니다.

from langchain_community.document_loaders import RecursiveUrlLoader

loader = RecursiveUrlLoader("https://example.com")
documents = loader.load()

9.DirectoryLoader

지정된 디렉토리 내의 모든 파일을 로드하여, 특정 파일 확장자를 필터링할 수 있습니다.

from langchain_community.document_loaders import DirectoryLoader

loader = DirectoryLoader("path/to/directory", glob="**/*.txt")
documents = loader.load()

10.GDriveLoader

구글 드라이브에서 파일을 로드합니다.

from langchain_community.document_loaders import GDriveLoader

loader = GDriveLoader("your_folder_id", "credentials.json")
documents = loader.load()

11.AzureBlobStorageFileLoader

Azure Blob Storage에서 파일을 로드합니다.

from langchain_community.document_loaders import AzureBlobStorageFileLoader

loader = AzureBlobStorageFileLoader("your_connection_string", "container_name", "blob_name")
documents = loader.load()

로드한 데이터는 아래와 같이 불러와집니다.

Document(page_content="This is a sample text file.\nIt contains multiple lines of information.\nLangChain makes it easy to work with documents.")

핵심적으로 쓰이는 것들만 찾아왔는데요.

그 외에 정말 다양한 Loader들이 있습니다.

Custom Loader

정해져있는 Loader를 쓸 수도 있지만, 본인이 원하는대로 만들어서 쓸 수도 있습니다.

from langchain_core.document_loaders import BaseLoader
from langchain_core.documents import Document

class MyCustomLoader(BaseLoader):
    def __init__(self, path):
        self.path = path

    def load(self):
        # Step 1. 데이터 읽기
        with open(self.path, "r", encoding="utf-8") as f:
            raw_text = f.read()

        # Step 2. Document 객체로 변환
        doc = Document(
            page_content=raw_text,
            metadata={"source": self.path}
        )
        return [doc]

방법은 정말 간단합니다. 로드한 데이터를 읽고, 텍스트 형태로 만들어서 Document객체에 넣어주시면 됩니다.

예를 들어서 log 데이터를 불러오고 싶다면 다음과 같이 구현할 수 있습니다.

class LogFileLoader(BaseLoader):
    def __init__(self, filepath):
        self.filepath = filepath

    def load(self):
        with open(self.filepath, "r", encoding="utf-8") as file:
            lines = file.readlines()

        logs = "\n".join(line for line in lines if "ERROR" in line)
        return [Document(page_content=logs, metadata={"source": self.filepath})]

이번 포스팅에서는 Langchain Document loaders 종류에 대해서 알아봤는데요.

다음 포스팅에서도 RAG를 구현할 수 있는 다음 단계를 차근차근 알려드릴게요!

궁금한 점 있으시면 언제든지 댓글 남겨주세요!

RAG(Retrieval-Augmented Generation) 기본 개념 정리 및 Langchain코드 예제

컴공누나 — Thu, 3 Apr 2025 23:41:58 +0900

최근 ChatGPT의 등장으로 LLM에 대한 관심이 커지고 있습니다.

하지만 써보신 분들은 아시겠지만, 분명히 LLM도 한계점이 존재합니다.

예를 들어,

최신 정보 반영이 안되어 있다거나,

특정 기업 내에서 쓰는 비밀 문서 등

ChatGPT가 답변할 수 없는 부분도 있습니다.

그렇다면 이 정보를 넣기 위해 큰 모델을 다시 학습시켜야할까요?

아뇨! 꼭 그럴 필요는 없습니다.

관련된 문서를 프롬프트로 같이 넣어줌으로써 ChatGPT가 이를 이해하고, 답변해 줄 수 있습니다.

이것이 바로 RAG의 개념입니다.

ChatGPT에게 관련 문서를 던져주면서 "이게 관련 정보니까 내가 묻는말에 답해!"라고 하는 것과 같습니다.

그럼 이번 포스팅에서 더 자세히 알아볼게요!

더 나아가 실습까지 할 예정이니 끝까지 봐주시면 더 좋겠습니다.

RAG란?

RAG는 Retrieval Augmented Generation이라는 이름에서부터 알 수 있듯이, 관련된 정보를 검색하여 먼저 찾고, 이를 LLM에 같이 넣어 최종 답변을 생성하는 하나의 파이프라인입니다. 간단히 말씀드리자면, 검색 기반의 생성이라고 할 수 있습니다.

더 이해하시기 쉽게 플로우를 그려드릴게요!

먼저 일반적인 구조를 볼게요. LLM은 별도로 학습하지 않은 이상, 당연히 사내에 있는 A라는 사람의 정보를 모릅니다.

하지만 RAG구조에서는 A에 대한 정보를 검색 모델이 문서에서 한번 검색하고, LLM에게 함께 제공하기 때문에, LLM은 잘 답변해줍니다.

앞에 검색하여 정보를 제공해 주는 로직이 하나 추가된 것이라고 생각하시면 됩니다.

RAG의 필요성

위에서 RAG가 뭔지에 대해 설명을 드렸는데요.

"그냥 LLM 다시 학습시키면 되는거 아님?" 생각이 드실 수 있어요.

물론 맞는 말입니다. 돈과 시간만 많으면 사실 LLM을 재학습 시키는 것이 가장 편한 방법이긴 하죠.

하지만 웬만한 기업에서도 매번 학습시키기에는 부담이 되는 것은 사실입니다.

학습을 한다고 하더라도 LLM에서 자주 나타나는 할루시네이션이 나타날 가능성도 있습니다.

따라서 보다 적은 비용으로 정확한 정보를 답변하기 위해 RAG구조를 사용합니다.

RAG의 구조

RAG가 뭐고, 왜 필요한지 알았으니 이제 자세한 구조에 대해서 알아볼까요?

RAG는 크게 문서를 검색하는 Retriever, 답변을 생성하는 Generator로 나뉘어져 있습니다.

Retriever

"검색기" 역할을 하는 부분입니다.
입력받은 질문과 가장 관련 깊은 문서를 찾아줍니다.
방법으로는 Lexical, Dense, Hybrid Search가 있습니다.
문서는 다양한 형태가 될 수 있습니다.

Generator

일반적으로 우리가 알고있는 LLM(GPT, LLama 등)을 뜻합니다.
Retriever로 부터 받은 정보를 바탕으로 답변을 생성합니다.

간단한 코드 예시(Langchain사용)

Langchain은 LLM을 쉽게 다룰 수 있게 도와주는 파이썬 라이브러리입니다.

Langchain으로도 아주 쉽게 RAG를 구현하실 수 있습니다.

코드가 엄청 간단하죠?

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chat_models import ChatOpenAI
from langchain.chains import RetrievalQA
from langchain.text_splitter import CharacterTextSplitter
from langchain.document_loaders import TextLoader

# 1. 문서 로드 및 분할
loader = TextLoader("example.txt")
documents = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50)
docs = text_splitter.split_documents(documents)

# 2. 문서 임베딩 및 벡터 저장 (FAISS 사용)
embedding = OpenAIEmbeddings()
db = FAISS.from_documents(docs, embedding)

# 3. 검색 + 생성 체인 구성
retriever = db.as_retriever()
llm = ChatOpenAI(model_name="gpt-3.5-turbo")
qa = RetrievalQA.from_chain_type(llm=llm, retriever=retriever)

# 4. 질문하고 답 받기!
query = "이 문서의 핵심 내용이 뭐야?"
result = qa.run(query)
print(result)

여기서 등장하는 FAISS는 벡터 DB인데요. 사용 방법은 아래 포스팅에 자세히 적어두었습니다.

물론 Langchain 사용법과는 살짝 다르긴 하지만, 기본적인 동작 과정이 궁금하시면 참고해주세요!

대용량 데이터의 유사도 검색 라이브러리 faiss 사용하기

faiss faiss는 대용량의 데이터 간의 유사도를 빠르게 계산해주는 유사도 검색 라이브러리입니다. 예를 들어 유사한 단어를 찾고 싶다! 하시면 미리 임베딩된 단어들로 "인덱스"를 생성해 주시고, "

jaeyoon-95.tistory.com

이번 포스팅에서는 RAG 기본 개념에 대해서 알아봤는데요.

점점 더 심화 과정을 설명할 예정이니, 관심있으신 분들은 봐주시면 좋을 것 같아요!

읽어주셔서 감사합니다:)

ChatGPT 프롬프트 엔지니어링 잘 하는 방법

컴공누나 — Wed, 26 Mar 2025 22:57:35 +0900

ChatGPT가 나오고 나서 프롬프트 엔지니어링이 정말 중요해졌죠.

실제로 비개발자 분들도 프롬프트 엔지니어링을 잘 하시면

앱, 웹 등 쉽게 만드실 수 있습니다.

이번 포스팅에서는 프롬프트 엔지니어링을 어떻게하면 더 잘하는지

엔드류응 교수님께서 직접 올려주신 강의를 토대로 정리해볼게요.

프롬프트 엔지니어링 잘하는 방법

명확하고 구체적인 지시

첫 번째 방법은 명확하고 구체적인 지시를 하는 것입니다.

그 방법은 여러가지가 있는데요. 간단하게 먼저 정리해볼게요.

"", ```, ---, <>, <tag></tag>등의 구분자를 이용하여 입력의 구분된 부분을 명확하게 표시
HTML, JSON 형태와 같은 구조화된 출력 요구
모든 조건이 만족하는지 체크하도록 요구
적절한 예시 제공

사용전	사용후
이 고양이 장난감은 진짜 잘만든 것 같아요. 우리 야옹이가 진짜 잘 가지고 노는데, 어떻게만드셨나요? 정말 최고입니다. 위의 텍스트에서 어떤 상품을 산 것인지 알려줘.	입력받은 텍스트에 대해 어떤 상품을 산 것인지 JSON 형태로 출력해주세요. 다음을 따라서 해주세요. ## 예시 -입력 : 강아지 사료가 정말 질이 좋은 것 같아요. 우리 강아지가 건강해졌어요. -출력 : 강아지 사료 step1. 입력받은 텍스트에 상품명이 있는지 체크한다. step2. 출력이 json형태가 맞는지 체크한다. ## 입력 이 고양이 장난감은 진짜 잘만든 것 같아요. 우리 야옹이가 진짜 잘 가지고 노는데, 어떻게만드셨나요? 정말 최고입니다.

사실 엄청나게 어려운 task를 준 것은 아니라 둘 다 답변을 잘 하는데요.

그래도 명확하고 구체적으로 말한 쪽이 더 정교하게 추출했죠. 어려운 task에 적용할수록 결과값 차이가 많이 납니다.

모델에게 생각할 시간을 주기

두 번째는 모델에게 자체적으로 생각할 시간을 주는 것입니다.

사람도 어떤 문제를 줄 때 급하게 푸는 것과 시간을 가지고 푸는 것의 결과가 꽤 차이가 납니다.

step1, step2 등의 작업을 완료하는 데 필요한 단계를 명시
결론에 도달하기 전 자신만의 해결책을 찾도록 지시

사용전	사용후
철수가 사과 3개를 사고, 영희가 5개를 샀습니다. 둘이 합쳐 몇 개입니까?	철수가 사과 3개를 샀고, 영희는 5개를 샀습니다. Step 1: 철수가 산 개수를 계산하세요. Step 2: 영희가 산 개수를 계산하세요. Step 3: 두 개수를 더해서 총합을 구하세요. 마지막으로 정답을 말해주세요.

이번에도 간단한 예시라 다들 잘하지만, 확실히 생각할 시간을 주는 쪽이 더 정교하게 일을 처리하죠.

실제로 업무에 사용하다보면, 프롬프트를 어떻게 넣냐에 따라 받는 답변의 만족도가 달라집니다.

반복해서 프롬프트 수정하기

이제 질문의 답변을 잘 받는 방법을 배웠으니, 어떻게 더 나은 프롬프트를 만들 수 있는지 알아보겠습니다.

강의에서는 "반복적 작업으로 프롬프트 개발을 해야한다"라고 하셨는데요.

그 의미가 무엇인지 한번 살펴볼게요.

예를 들어 제가 파리 여행을 가는 데 chatgpt에게 계획을 세워달라고 하면, 다음과 같은 과정을 거칠 수 있습니다.

1step. 초기 계획 짜달라고하기
- 프롬프트 : 파리에서 3일간 여행할 건데, 여행 일정 짜줘.
> 너무 일반적인 결과라 답변이 마음에 안들 수 있음

2step. 조금 더 원하는 포인트를 구체적으로 적기(예술,역사 중심 + 걷기 최소화)
- 프롬프트 : 파리에서 3일간 여행할 건데, 예술과 역사 중심의 일정으로 짜줘. 걷는 시간은 하루 3시간 이하로 해줘.
> 관심사와 걷기 시간 제한이 생김

3step. 더 구체적으로 원하는 포인트 적기(하루에 3개 이하 명소 + 대중교통 위주 + 맛집)
- 프롬프트 : 파리에서 3일간 예술과 역사 중심으로 여행할 거야. 하루에 3개 이하의 명소만 추천해줘. 대중교통 이동 위주로 계획해줘. 그리고 맛집도 하루에 1곳씩 넣어줘.
> 명소 수 제한, 이동 방식 지정, 맛집 추가

위의 예는 명확하고 구체적인 예시, 생각할 시간 주기 등의 방식을 쓰지 않고 간단하게 작성해 보았는데요.

실제로 저 두 방법을 다 넣는다고 해도, 완전히 원하는 결과가 나오지 않을 수 있습니다.

그런 경우에는 프롬프트를 조금씩 수정해서 원하는 결과가 나오도록 반복적인 작업을 해야합니다.

이번 포스팅에서는 프롬프트 엔지니어링 잘 하는 방법에 대해서 알려드렸는데요.

다음 포스팅에서는 어떤 문제에 LLM을 적용할 수 있을지 말씀드릴게요.

궁금한 부분이 있다면 언제든지 댓글 남겨주세요!

LSA를 활용한 문서 의미 분석과 통계적 임베딩

컴공누나 — Wed, 19 Mar 2025 23:08:40 +0900

지난 포스팅에서는 통계적 임베딩 종류 중 하나인 TF-IDF에 대해 알려드렸습니다.

혹시 놓치신 분들은 아래 포스팅을 참고해주세요.

통계적 임베딩으로 문서의 핵심 단어를 찾는 TF-IDF

지난번 포스팅에서는 임베딩 모델 설명에 들어가기 앞서 토크나이저에 대해 알아봤는데요.아직 못보신 분들은 미리 보시는 것을 추천드립니다. 자연어처리 기초 토크나이저의 모든것! 종류부

jaeyoon-95.tistory.com

추가로 어떤 임베딩 종류가 있는지 궁금하시다면 아래 포스팅을 참고해주세요.

자연어 처리 임베딩의 등장 배경과 종류

어느 순간부터 딥러닝이 점점 핫해지기 시작했는데요.OpenAI의 ChatGPT가 공개되면서 LLM에 대한 관심이 폭주하기 시작했어요.이번 포스팅 시리즈는 초기 LM부터 LLM까지 자연어 처리 모델이 어떻게

jaeyoon-95.tistory.com

오늘은 통계적 임베딩 종류중 하나인 LSA에 대해서 알아볼게요.

LSA란?

LSA(Latent Semantic Analysis)란 잠재 의미 분석이라고 하는데요. LSA는 문서의 잠재 의미를 파악하는 기법입니다. 특이값 분해(SVD)를 활용하여 고차원 문서-단어 행렬을 저차원 의미 공간으로 변환하는 것이 핵심 원리인데요.

이 말이 어렵게 느껴지시는 분들이 계실겁니다. 조금 더 쉽게 이야기해볼게요.

도서관에서 책을 정리하는 일을 하고 있다고 가정할게요. 책 표지에는 어떠한 글자들이 적혀있었지만, 모르는 나라 언어였기 때문에 의미를 자세히 이해하지 못했습니다. 그러다 '비슷한 단어가 많이 등장하는 책들은 같은 주제일 가능성이 크다'라는 생각을 하게 됩니다.

책 1 : "강아지는 귀엽다. 강아지는 사람을 잘 따른다."
책 2 : "고양이는 독립적이고, 시크해서 더 귀엽다."
책 3 : "강아지와 고양이는 너무 귀엽다."

위와 같이 세 가지 책을 보면 강아지와 고양이는 모두 '귀엽다'라는 단어를 공유하고 있음을 발견할 수 있죠.

강아지 - 귀엽다, 고양이 - 귀엽다 따라서 강아지 - 고양이도 관련이 있음을 알 수 있습니다.

이처럼 비슷한 단어가 자주 나오는 문서를 묶어 주는 방법이 LSA입니다.

이제 LSA가 어떤 과정을 거쳐서 처리되는지 살펴볼게요!

이해를 돕기 위해 또 다른 예시를 정의할게요.

1. 문서-단어 행렬 생성(TDM, Term Document Matrix)

아래의 예시로 한번 살펴볼게요.

문서 1 : "고양이는 귀엽고 빠르다."
문서 2 : "강아지는 귀엽고 사랑스럽다."
문서 3 : "고양이는 빠르고 독립적이다."

단어	고양이	강아지	귀엽다	빠르다	사랑스럽다	독립적이다
문서 1	1	0	1	1	0	0
문서 2	0	1	1	0	1	0
문서 3	1	0	0	1	0	1

위의 표를 하나의 행렬로 나타내자면 아래와 같습니다.

2. 특이값 분해(SVD, Singular Value Decomposition)

특이값 분해는 행렬을 3개의 작은 행렬로 쪼개는 방법입니다. SVD는 복잡한 데이터를 단순하게 정리하는 마법같은 방법이라고 생각하면 되는데요. 아래와 같은 수식을 가집니다.

U : 문서의 특성을 나타내는 행렬(직교 행렬 mxm)
Σ : 중요한 정보를 담고 있는 대각 행렬(직교 행렬 mxn)
V^T : 단어의 특성을 나타내는 행렬(직사각 대각 행렬 nxn)

* 직교 행렬 : 자신과 자신의 전치 행렬의 곱 또는 이를 반대로 곱한 결과가 단위행렬이 되는 행렬

* 대각행렬 : 주대각선을 제외한 곳의 원소가 모두 0인 행렬

SVD의 개념이 헷갈리신다면 아래 포스팅에서 확인하시면 좋을 것 같아요!

특이값 분해(SVD) 쉽게 이해하기

특이값 분해 SVD는 머신러닝 공부하시는 분들은 정말 많이 들어보셨을 겁니다.생각보다 개념이 어렵기도 하고, 보고 봐도 이해가 잘 안되는 경우가 많을겁니다.이번 포스팅에서는 최대한 쉽게

jaeyoon-95.tistory.com

이제 위의 값을 하나씩 구해볼게요.

U는 문서들의 관계를 나타내는 행렬이라고 보시면 되는데요. 각 문서를 고유벡터로 표현하는 행렬이고, 비슷한 문서일수록 벡터가 비슷합니다. 문서 1은 (-0.577, -0.707, 0.408), 문서 2는 (-0.577, 0.707, 0.408), 문서 3은 (-0.577, 0, -0.816)입니다. 두 문서가 비슷할수록 이 두 벡터간의 거리는 가까워요.

V^T는 각 단어벡터들의 관계를 나타내는 행렬이라고 보시면 되는데요. 각 열이 하나의 단어라고 생각하시면 됩니다.

예를 들어 고양이는 (-0.577, 0.577, -0.577, 0, 0, 0), 강아지는 (-0.577, 0.577, -0.577, 0, 0, 0)입니다. 두 벡터가 거의 동일하기 때문에, 문서에서 비슷한 의미로 쓰일 가능성이 큽니다.

Σ는 중요한 정보를 담고있는 주제라고 생각하시면 됩니다. 즉, 데이터 내에 가장 중요한 패턴과 그 강도를 나타내는 숫자들인데요. 값이 클수록 강력하다고 생각하시면 됩니다.

3. 차원 축소(k값 선택)

LSA의 핵심 목표는 문서와 단어 간의 잠재적인 의미를 추출하는 것인데, 원본 문서-단어 행렬은 고차원이고, 단어들은 문맥에 따라 다른 의미를 가질 수 있죠. SVD를 통해서 차원을 축소하면 중요한 의미 구조만 남기고, 불필요한 정보는 제거할 수 있었어요.

하지만 이 과정 이후 k를 설정하여 그 만큼 차원을 더 줄이는데요. 이 과정은 아래와 같은 이유 때문에 진행됩니다.

동의어나 유사한 의미를 가진 단어 통합(동일한 의미를 가진 문서를 유사 벡터로 표현)
- 차원 축소를 하면 '충성스럽다', '믿을만하다'같은 단어가 비슷한 의미를 공유하도록 변환됩니다.
노이즈 제거
- 특정 문서에만 등장하는 단어나, 데이터에 포함된 불필요한 단어들은 의미있는 정보가 아닙니다.
- 따라서 차원을 축소하면 노이즈가 제거되어 더 깔끔한 의미 공간을 만들 수 있습니다.
차원의 저주 해결
- 차원의 저주는 행렬에 값이 별로 안들어있고, 다른 값들은 모두 0인데, 크기가 엄청 큰 비효율적인 행렬을 뜻합니다.
- 이 행렬은 연산이 비효율적이며, 학습도 매우 어렵습니다.
- 차원 축소를 한다면, 연산 효율이 증가하고, 의미 구조를 더 효과적으로 학습할 수 있습니다.

차원 축소하는 것은 어렵지 않습니다. 예를 들어 k = 2라고 한다면, 각 U, V^T, Σ값은 다음과 같습니다.

k=2로 차원이 축소된 U

k=2로 차원이 축소된 V^T

k=2로 차원이 축소된 Σ

어느정도로 차원을 축소할 지 k만 잘 설정된다면, 차원의 축소는 어렵지 않게 할 수 있습니다.

그럼 k값을 잘 설정해 줘야 할텐데요. k값은 어떻게 설정해줘야할까요?

k값 선택을 잘 하기 위해서는 아래와 같은 방법들이 있습니다.

(1) Cumulative Explained Variance

특이값의 크기가 데이터의 중요도를 나타내기 떄문에, Cumulative Explained Variance가 90%이상을 유지하는 최소 차원을 선택하면 좋습니다. 즉, 특이값이 크고 중요한 차원만 남기고 나머지는 제거하는 방법이죠.

(2) Elbow Method

k를 여러 개 설정하고, Cumulative Explained Variance을 그래프로 그려서 급격한 변화가 멈추는 지점을 선택합니다.

차원이 높을수록 정보량은 증가하지만, 특정 짖머에서는 증가량이 급격히 감소합니다. 이 꺾이는 점이 최적의 차원이라고 할 수 있어요.

(3) 경험적 최적 차원 선택

데이터마다 최적 차원수가 다르긴 하지만, 일반적으로 아래와 같이 나옵니다.

작은 데이터셋 : 50 ~ 100차원
중간 크기 데이터셋 : 100 ~ 300차원
대형 데이터셋 : 300 ~ 500차원

경험적으로 위 범위 내에서 테스트한 뒤, 성능 최적화가 될 수 있습니다.

구현

코드로 구현하면 아래와 같습니다.

라이브러리 사용한 버전과 안한버전 둘 다 있으니 살펴 보시면 좋을 것 같아요.

import numpy as np
from sklearn.decomposition import TruncatedSVD

# 문서-단어 행렬 (예제 데이터)
A = np.array([[1, 0, 1, 1, 0, 0],
              [0, 1, 1, 0, 1, 0],
              [1, 0, 0, 1, 0, 1]])

# 1. 라이브러리 사용 (sklearn TruncatedSVD)
k = 2  # 축소할 차원 수
svd = TruncatedSVD(n_components=k)
A_reduced_sklearn = svd.fit_transform(A)
print("LSA (라이브러리 사용) - 차원 축소된 문서 행렬:")
print(A_reduced_sklearn)

# 2. 직접 구현 (numpy SVD)
U, Sigma, VT = np.linalg.svd(A, full_matrices=False)
Sigma_k = np.diag(Sigma[:k])  # 상위 k개 특이값만 선택
U_k = U[:, :k]  # U에서 k개 차원 선택
A_reduced_manual = np.dot(U_k, Sigma_k)  # 차원 축소 적용

print("\nLSA (직접 구현) - 차원 축소된 문서 행렬:")
print(A_reduced_manual)

장단점

장점

단점

단어간 의미적 관계 파악 가능
- TF-IDF는 단순 빈도수로 계산했지만, SVD를 통해 단어 간 숨겨진 의미 관계를 찾을 수 있습니다.
차원 축소를 통한 연산 속도 향상
- 차원을 줄이면, 메모리 사용량이 줄기 때문에 연산 속도가 빨라집니다.
노이즈 제거 효과
- 문서 간의 의미적 유사도를 측정할 때 , 덜 중요한 정보를 자동으로 제거하는 효과가 있습니다.
검색 시스템에 활용 가능
- 검색어가 정확히 일치하지 않더라도, 의미적으로 유사한 문서를 검색할 수 있습니다.

새로운 단어 추가시 다시 계산 필요
- SVD는 한 번 계산된 후 새로운 문서가 추가되면 다시 전체 데이터를 계산해야합니다.
- 즉, 동적으로 변하는 환경에서 적용하기가 어렵습니다.
결과 해석의 어려움
- LSA는 통계적 기법을 기반으로 하기 때문에, 각 차원이 어떤 의미인지 명확하게 해석하기가 어렵습니다.
단어 순서를 고려하지 않음
- 단어의 순서는 전혀 고려하지 않고, 등장 빈도위주로 사용을 합니다.

사용하는 곳

사용처	설명
검색 엔진	검색어와 정확히 일치하지 않아도, 의미적으로 유사한 문서를 찾을 수 있기 때문에, 검색엔진에도 쓰일 수 있습니다.
문서 분류&토픽 모델링	문서에 등장하는 단어의 패턴을 분석하여 자동으로 분류하는 데 사용됩니다.
추천 시스템	사용자가 읽은 문서나 본 영화의 내용을 분석하여, 의미적으로 유사한 콘텐츠를 추천할 수 있습니다.
의미 분석	문장에서 단어 간의 의미적 유사성을 분석할 수 있습니다.
문서 요약	긴 문서에서 핵심 내용을 뽑아내는 작업에 사용될 수 있습니다.

이번 포스팅은 통계적 임베딩 방법 중 하나인 LSA에 대해 알아봤습니다.

LSA는 문서-단어 간의 관계를 고려해서 임베딩해주는 방법입니다.

다음 포스팅에서는 문서 내에 주제를 확률적으로 추출하는 기법인 LDA에 대해 알아볼게요!

질문있으시면 댓글 언제든지 남겨주세요!

특이값 분해(SVD) 쉽게 이해하기

컴공누나 — Tue, 18 Mar 2025 23:25:31 +0900

특이값 분해 SVD는 머신러닝 공부하시는 분들은 정말 많이 들어보셨을 겁니다.

생각보다 개념이 어렵기도 하고, 보고 봐도 이해가 잘 안되는 경우가 많을겁니다.

이번 포스팅에서는 최대한 쉽게 특이값 분해에 대해 알려드리려고 하는데요.

혹시나 이해가 되지 않는다면 언제든지 댓글 남겨주세요!

특이값 분해(SVD,Singular Value Decomposition)란?

특이값 분해는 행렬을 여러 개의 작은 행렬로 쪼개서 더 쉽게 다룰 수 있도록 만드는 방법입니다.

예를 들어서 밴드 음악이 있다고 가정해볼게요. 이 밴드 음악에는 기타, 드럼, 베이스, 보컬이 하나로 섞여 만들어지죠.

근데 우리가 베이스를 연습하는 사람들이라고 한다면, 이 음악에서 베이스 소리만 똑 떼어내서 들으면 참 좋겠죠.

그럼 기타, 드럼, 보컬 소리를 제거하고, 베이스 소리만 남기게 됩니다.

이게 바로 특이값 분해인데요. 행렬을 여러개의 중요한 부분으로 쪼개서, 원하는(중요한) 정보만 남길 수 있게 해주는 방법입니다.

특이값 분해 계산 방법

특이값 분해는 아래의 식을 만족합니다.

A : mxn 크기의 원본 행렬
U : mxm 크기의 직교 행렬
Σ : mxn 크기의 대각 행렬
^ : nxn 크기의 직교 행렬

직교, 대각 행렬이 뭔지 헷갈리시면 아래를 클릭하셔서 확인해주세요.

직교 행렬

직교 행렬은 자기 자신의 전치 행렬과 역행렬이 동일한 행렬입니다.

즉, 행렬 Q가 직교행렬이 되려면 아래의 조건을 만족해야합니다.

특징은 다음과 같습니다.

역행렬이 전치행렬과 같다.
벡터의 길이를 유지한다.
직교 행렬의 열과 행은 서로 직교하며, 크기가 1인 단위벡터이다.(서로 수직이며 길이가 1이다)

구체적인 예를 들자면 아래와 같은 행렬이 직교 행렬이라 할 수 있겠습니다.

대각 행렬

대각 행렬은 대각선 이외의 원소가 모두 0인 행렬입니다.

즉, 아래와 같은 형태를 만족합니다.

대각 원소는 모두 0이 아니어야합니다.

특이값 분해는 원본 행렬인 A를 좌측 특이벡터 U, 특이값 행렬 Σ, 특이 벡터 행렬 ^ 으로 나눕니다.

이제 예를 들어서 계산을 하나씩 해볼텐데요. 차근차근 따라와주세요!

혹시나 왜 이수식이 나왔는지 이해가 안된다면, 아래에서 유도해드릴테니, 일단은 한번 읽어주세요!

A행렬은 다음과 같이 정의하겠습니다.

(1) A^TA와 AA^T계산

위의 과정은 고유값과, 고유벡터를 구하는 과정입니다.

(2) 특이값 Σ 구하기

여기서 고유값을 구하면

이렇게 나오는데요.

특이값은 고유값의 제곱근으로 구할 수 있습니다.

(이것도 왜 그런지 아래에서 설명해드릴게요)

이 값으로 대각행렬인 Σ를 구할 수 있습니다.

(3) U와 V행렬 구하기

A^TA의 고유벡터를 구하면 행렬 를 구할 수 있습니다.

따라서 ^ 는 다음과 같이 나올 수 있습니다.

AA^T를 이용하면 U벡터를 구할 수 있는데요. AA^T의 고유벡터를 계산하면 아래와 같습니다.

따라서 최종적으로는 다음과 같이 구해집니다.

특이값 분해 수식 유도

특이값 분해가 왜 저런 수식을 가지게 되었는지 직접 유도해보겠습니다.

들어가기 전 특이값 분해는 고유값 분해를 일반화한 수식이라는 것을 알아주세요!

(1) 고유값 분해

고유값과 고유 벡터는 다음과 같은 수식을 만족하는데요.

A : nxn 크기의 정방 행렬
v : 행렬 A의 고유벡터 (0이 아닌 벡터)
λ : 행렬 A의 고유값 (스칼라값)

위의 조건을 만족하고, 그 의미는 행렬 A가 벡터 v에 작용했을 때, 방향은 그대로고 크기만 λ배 변한다는 것을 의미해요.

만약 고유값, 고유벡터를 모르신다면 아래 포스팅을 먼저 봐주세요!

가장 쉽게 설명하는 고유값과 고유벡터

최근 자연어 처리의 기본에 대해 포스팅을 시작했는데요.통계적 임베딩을 설명하는데 반드시 필요한 개념인데,해당 포스팅에 담기에는 또 너무 길더라고요.그래서 고유값, 고유벡터 먼저 설명

jaeyoon-95.tistory.com

만약에 행렬 A의 고유벡터가 n개 있다고 가정해 볼게요.

이 행렬을 V라고 정의하고 하나로 묶으면 아래와 같이 표현할 수 있습니다.

그럼 이제 전체 수식으로 다시 돌아와 볼게요.

이걸 행렬 형태로 한번에 정리하면 아래와 같이 수식을 정리할 수 있습니다.

그럼 위에서 정의한 V에 의해 수식을 변환할 수 있습니다.

오른쪽은 각 고유벡터에 대응하는 고유값을 곱한것이기 때문에 다음과 같이 변환 가능합니다.

이 값을 우리는 Λ로 정의해줄 수 있습니다.

V의 역행렬을 곱해주면 아래의 수식을 구할 수 있습니다.

각 행렬의 의미는 다음과 같습니다.

V^-1 : 원래 좌표계를 "고유 벡터 좌표계"로 변환
Λ : 고유값만큼 크기를 변환
V : 다시 원래 좌표계로 돌림

의미를 한번 정리해보면 고유값 분해라는 것은 행렬을 고유벡터와 고유값을 이용해 분해하는 방법입니다.

고유벡터 행렬 V를 이용해 원래 행렬을 변환한다면, 단순한 대각행렬인 Λ으로 표현할 수 있습니다.

즉, 위의 수식을 통해 "축을 따라 크기만 변하는 연산"으로 해석될 수 있다는 이야기죠!

그럼 이게 왜 특이값 분해랑 연관이 있는 걸까요?

기존 고유값 분해는 행과 열의 크기가 같은 정방행렬에서만 적용이 가능합니다.

즉, 직사각형(비정방) 행렬에서는 적용할 수 없다는 단점이 있어요.

그래서 더 일반적인 방법인 SVD가 필요하게 되었습니다.

(2) 일반적인 고유값 분해 SVD

위에서 SVD는 직사각 행렬도 가능하게 만든다고 말씀드렸습니다.

사실 수식 자체가 정사각 행렬 계산으로 되기 때문에, 한 번에 직사각 행렬로 계산하게 된다면, 수정되는 부분이 굉장히 많을텐데요.

그래서 우리는 직사각 행렬 A를 아래와 같이 만들어줄 수 있어요.

A가 mxn크기를 가진다고 하면, nxm크기를 가지는 A^T를 곱해줄 때 mxm, 혹은 nxn크기를 가지게 됩니다.

그렇다면 이 값은 정방행렬이 되겠죠!

그럼 위에서 알게된 고유값 분해 수식에 대입할 수 있게 됩니다.

V, Λ 값은 이렇게 정의할 수 있게 됩니다.

V : A^TA의 고유벡터 행렬
Λ : A^TA의 고유값 행렬

반대로 AA^T도 대입해 줄 수 있는데요.

U, Λ값은 이렇게 정의할 수 있게 됩니다.

U : AA^T의 고유벡터 행렬
Λ : AA^T의 고유값 행렬

위의 수식에서 보면 고유 벡터 행렬은 다르지만, 고유값 행렬은 동일한 것을 확인할 수 있는데요.

이것은 아래 펼치기에서 상세하게 확인하실 수 있어요.

먼저 A^TA의 고유값과 고유벡터 수식 정의를 하면 다음과 같습니다.

이제 왼쪽에 A행렬을 곱해주겠습니다.

이를 새로 정리하면 아래와 같이 할 수 있습니다.

여기서 Av를 새로운 벡터라고 정의한다면, AA^T에 대한 고유값, 고유벡터 정의가 가능해집니다.

λ는 모든 식에서 동일하게 등장하는 것을 알 수 있죠.

따라서 AA^T, A^TA의 고유값은 동일하다고 할 수 있습니다.

SVD설명할 때 "특이값은 고유값의 제곱근으로 설정한다"라고 말씀드렸는데요.

특이값은 실제 변형된 크기를 나타내야하는데, 우리가 정방행렬로 만들려고 AA^T, A^TA처럼 A행렬을 두 번 곱해줬습니다.

따라서 원래 크기를 알고싶다면 제곱근을 취해줘야합니다.

아래와 같은 수식을 얻을 수 있습니다.

이제 원래 행렬인 A를 위에서 구했던, U, V, Σ로 표현해 보겠습니다.

A^TA의 고유값과 고유벡터 수식을 적용시켜볼게요.

이제 양 변에 A를 곱해보겠습니다.

λ는 스칼라이기 때문에 다음과 같이 앞으로 뺄 수 있습니다.

그럼 다음과 같은 수식이 만들어집니다.

왜 두 행렬의 고유값이 같은지 증명할 때와 비슷한 유도식이 나오게 됩니다.

위의 식을 보면 Avi자체를 하나의 벡터로 보면, AA^T의 고유벡터라고 할 수 있습니다.

그럼 AA^T의 고유벡터는 ui이기 때문에, Avi는 ui의 배수 형태가 됩니다.

아래와 같이 수식을 적어줄 수가 있겠네요.

여기서 c값은 특이값인 Σ으로 바꿔주시면 됩니다. 왜 바꿔주는지는 위에서도 말씀 드렸습니다.(=원래 크기를 알고싶기 때문)

그럼 이렇게 표현이 가능하겠죠!

양 변에 V^-1를 곱해주면 우리가 알고있는 특이값 분해의 식이 완성됩니다.

각 행렬의 의미

특이값 분해가 나누는 것은 알겠는데, 각 행렬이 어떤 의미를 가지는지 궁금하시죠?

아래서 하나씩 알려드릴게요!

U 행렬이 가지는 의미

A행렬이 가진 기본적인 패턴을 나타내는 행렬입니다. U의 각 열은 A의 특징 패턴을 나타내는 벡터입니다.

Σ행렬이 가지는 의미

A행렬이 가진 중요한 정보의 강도를 나타내는 행렬입니다. 숫자가 클수록 중요한 정보입니다.

Σ는 대각행렬인데, 대각선에 특이값이 들어갑니다. 특히 데이터를 압축할 때 많이 사용됩니다.

^ 행렬이 가지는 의미

A행렬이 어떤 방향을 가지고 있는지 나타내는 행렬입니다.

^ 의 행은 A의 원본 데이터가 어떤 방향으로 변하는지를 나타냅니다.

이번 포스팅에서는 특이값 분해 SVD에 대해 알아봤습니다!

살짝 어려우실 수 있는데요!

이해 안되시면 댓글로 질문남겨주세요~!

가장 쉽게 설명하는 고유값과 고유벡터

컴공누나 — Mon, 17 Mar 2025 22:00:13 +0900

최근 자연어 처리의 기본에 대해 포스팅을 시작했는데요.

통계적 임베딩을 설명하는데 반드시 필요한 개념인데,

해당 포스팅에 담기에는 또 너무 길더라고요.

그래서 고유값, 고유벡터 먼저 설명한 뒤, 임베딩을 설명하려고합니다.

이번 포스팅에서 고유값, 고유벡터를 정말 쉽게 설명하려고해요.

끝까지 잘 따라와주시면 감사할 것 같습니다.

질문과 의견은 언제든지 환영합니다.

고유값(Eigenvalue)과 고유 벡터(Eigenvector)란?

선형대수 공부하면 나오는 용어이죠. 처음 배우시는 분들도 계시고 잠시 까먹으신 분들도 계실 수 있어요.

고유 벡터라고 하는 것은 방향이 변하지 않는 벡터입니다.

만약 사람이 에스컬레이터를 탄다면, 방향이 변하지 않고 쭉 가죠. 이 때 사람이 고유벡터, 이동한 거리가 고유값이라고 할 수 있어요.

즉, 고유값은 고유 벡터가 얼마나 늘어나거나, 줄어드는지 나타내는 값입니다.

반면 회전문에 사람이 지나치면 사람의 방향이 완전 바뀌어버리게 됩니다. 이 것은 고유벡터가 아닙니다.

수학적으로 행렬 A가 벡터 v에 대해 다음을 만족할 때

v는 고유벡터
λ는 고유값

이렇게 정의합니다.

의미를 살펴보면 어떠한 행렬 A가 어떤 벡터 v에 작용했을 때, 방향은 그대로이고 크기만 λ배로 변한다는 것을 의미합니다.

이 때 v, λ값은 A의 고유벡터, 고유값이라고 불립니다.

고유값과 고유 벡터 구하는 방법

그럼 고유값과 고유벡터에 대해서 알아봤으니, 이제는 어떻게 구하는지 한번 펴볼게요.

예시로 보여드리는 것이 더 쉬울 것 같아서 A행렬을 아래와 같이 정의하도록 하겠습니다.

고유값, 고유 벡터를 구하기 위해서는 특성 방정식을 구해야하는데요.

만약 이 개념을 모르겠다면, 아래 펼치기를 하셔서 확인해주세요!

step1. 초기 고유벡터, 고유값을 만족하는 식

A는 nxn행렬
v는 nx1 벡터(고유벡터, 0이 아닌 벡터)
λ는 고유값(스칼라)

step2. 식 변환

먼저 모든 수를 좌변으로 넘겨볼게요.

그럼 이제 공통된 벡터 v로 묶을 수 있게 되었습니다. 한번 묶어볼게요.

여기서 새로운 행렬인 (A-λI)라는 행렬이 나오게 됩니다.

이 행렬이 어떤 벡터 v에 대해 0벡터를 만들려면, 행렬이 역행렬이 없어야합니다.

v벡터는 0이 아닌 벡터이기 때문에, 행렬식은 다음과 같이 0이 되어야합니다.

"v벡터와 곱해져서 수식을 0으로 만들 수 있지 않나요?" 궁금 하실 수 있는데요.

앞에 설명에서도 말씀 드렸듯이, 고유벡터는 방향을 바꾸지 못합니다. 따라서 어떻게 해서든 기존 수식을 0으로 만들 수 없습니다.

역행렬이 존재하려면 행렬식(det)이 0이 아니어야한다.
만약 det가 0이면 행렬은 특이행렬이 되어 역행렬이 존재하지 않는다.

위의 선형대수의 기본 개념들 때문에, 위의 식을 만족해야합니다.

이 식이 바로 특성방정식(Characteristic Equation)입니다.

그럼 이제 특성방정식을 적용해볼게요.

따라서 λ값은 2와 3입니다. 이 값이 바로 고유값입니다.

고유값을 구했으니, 고유벡터를 한번 구해볼게요.

고유벡터는 앞서 구한 고유값을 하나씩 넣어서 구할 수 있습니다.

λ = 3인 경우

위에서 얻은 식에 3을 대입해 볼게요.

그럼 아래와 같은 식을 얻을 수 있는데요.

마지막으로 구한 행렬 값을 식에 대입을 해봅시다.

v = (x, y)라고 했을 때, x = 2y가 나오는데요.

따라서 대략적으로 다음과 같이 표현할 수 있습니다.

v = (-2, -1), (4, 2) 등 수많은 벡터가 될 수 있습니다. 단, 0은 안됩니다.

λ = 2인 경우

2의 값을 가질 경우에도 수식에 대입하면 행렬을 얻을 수 있어요.

여기에서도 v = (x, y)로 정의하고 식을 구할 수 있는데요. x = y값을 얻을 수 있습니다.

즉, 정말 간단하게 나타내면 아래와 같은 값을 얻을 수 있어요.

마찬가지로 v = (4, 4), (10, 10) 등 0을 제외한 수많은 벡터가 될 수 있어요.

왜 머신러닝에서 중요한가?

그럼 고유값, 고유벡터가 머신러닝에서 왜 중요한걸까요?

이 값을 알게 됨으로써 데이터의 핵심을 잘 파악하고, 복잡한 문제를 쉽게 풀 수 있기 때문입니다.

예를 들어 데이터의 핵심인 나무젓가락이 있다고 해볼게요.

여러 데이터가 표현되면서 또 다른 데이터인 고무 찰흙이 나무젓가락에 덕지덕지 붙습니다. 그럼 데이터가 점점 무거워지겠죠.

그래서 데이터의 핵심만 잘 발라내는 것이 중요합니다. 이게 바로 고유 벡터를 찾는 것이라고 할 수 있죠.

간단히 말하면, 데이터의 본질적인 특징을 잘 나타내는 방향을 찾는다고 보시면 됩니다.

추후 배울 PCA(주성분 분석) 등에서 이용됩니다.

오늘은 고유값과 고유벡터에 대해 알아보았는데요!

궁금한 점 있으면 언제든지 댓글 남겨주세요!

읽어주셔서 감사합니다.

통계적 임베딩으로 문서의 핵심 단어를 찾는 TF-IDF

컴공누나 — Mon, 10 Mar 2025 22:58:22 +0900

지난번 포스팅에서는 임베딩 모델 설명에 들어가기 앞서 토크나이저에 대해 알아봤는데요.

아직 못보신 분들은 미리 보시는 것을 추천드립니다.

자연어처리 기초 토크나이저의 모든것! 종류부터 최신 트렌드까지!

지난 포스팅에서는 자연어 처리가 무엇이고, 어떤 방법들이 있는지 정말 간단하게 알아봤습니다.혹시 아직 자연어처리에 대한 개념이 잘 안잡혔다고 느껴지신다면,아래의 포스팅을 먼저 보고

jaeyoon-95.tistory.com

이번 포스팅부터는 임베딩 방법론에 대해 하나씩 살펴볼텐데요.

오늘은 그 첫 번째로 TF-IDF에 대해 살펴볼까 합니다.

임베딩은 어떤 방법이 있는지 궁금하시다면 아래 포스팅도 참고해주세요.

자연어 처리 임베딩의 등장 배경과 종류

jaeyoon-95.tistory.com

그럼 본격적으로 TF-IDF에 대해서 알아보도록 하겠습니다.

TF-IDF란?

TF-IDF(Term Frequency-Inverse Document Frequency)는 문서에서 단어의 중요도를 계산하는 방법인데요. 간단하게 말씀드리자면, 각 단어가 문서 내에서 얼마나 중요한지를 측정하는 데 사용됩니다. TF는 단어 빈도인 Term Frequency와 IDF Inverse Document Frequency의 약자입니다. 살짝 어렵게 느껴지실 수도 있다고 생각되는데요. 조금만 더 쉽게 풀어서 말씀드려볼게요.

예를들어 '아기 돼지 삼형제'라는 동화책을 읽는다고 상상해 볼게요. 이 동화책에는 어떤 단어가 가장 많이 나올까요?

'돼지', '집', '늑대' 등이 가장 많이 나올것이라는 생각이 듭니다. 그럼 자연스럽게 '돼지'라는 단어가 많이 나오기 때문에, 중요하다고 생각할 수 있을텐데요. 생각해보면 '돼지'는 다른 동화책에서도 정말 많이 사용이 되죠. 그렇다면, 이 '돼지'는 특별한 단어라고 할 수 있을까요? '특별하다' 보다는 '흔하다'에 더 가깝게 되죠. 그럼 '아기 돼지 삼형제'라는 동화책 내에서 등장하는 다른 단어인 '벽돌집'은 비교적 다른 동화책에 덜 나오기 때문에 이 책 내에서는 더 특별한 단어라고 볼 수 있습니다.

이것이 TF-IDF의 기본 개념인데요. 문서에서 중요한(특별한) 단어를 찾기 위해 만들어진 방법입니다.

TF

첫 번째로 TF에 대해 먼저 설명드릴게요. TF는 간단하게 '단어가 얼마나 자주 나오니?'를 측정한다고 생각해주세요.

'돼지'가 책에서 10번 나왔고, '벽돌집'이 5번 나왔다고 할게요. '돼지'는 얼핏보면 문서 내에서 더 중요하게 보일 수 있죠.

하지만 앞서 말씀드린 것 처럼 '돼지'는 다른 동화책에서도 흔히 등장하는 단어입니다.

따라서 더 중요하고, 특별한 것이 아니다고 여겨집니다.

그럼 TF는 어떻게 계산하는지 한번 알아볼게요.

단어가 그 문서에 얼마나 많이 나왔는지를 나타내는 값이라고 볼수 있습니다. 전체 문서 단어중 해당 단어가 차지하는 비율과 같으니까요!

따라서 숫자가 클수록 더 많이 나온 단어라는 것을 알 수 있습니다.

예를 들어 '돼지'는 10번, '늑대'는 6번, '벽돌집'은 5번, 전체 단어개수가 100개라고 해볼게요.

'벽돌집'의 TF를 구해보겠습니다.

'벽돌집'은 전체 문서의 5%만큼 등장한 단어입니다.

IDF

IDF는 '얼마나 희귀한 단어인가?'에 대해 계산하는 방법입니다.

이 방법은 빠르게 수식 먼저 보고 설명드릴게요.

어떤 단어가 많은 문서에 등장하면 흔한 단어라 중요도가 낮아지는데요.

반대로 어떤 단어가 특정 문서에서만 나오면 희귀하고 중요할 가능성이 높습니다.

따라서 우리는 자주 등장하는 단어의 중요도를 먼저 낮춰줘야합니다. 동시에 희귀한 단어의 중요도는 높여야합니다.

위의 수식을 살펴보면 단어가 등장한 문서의 개수가 많을수록 분모가 커질텐데요. 따라서 자연스레 그 중요도는 낮아지게 됩니다.

참고로 분모의 '단어 t를 포함한 문서의 개수'는 '문서 빈도수'이며 DF(Document Frequency)라고도 합니다.

따라서 아래와 같이 수식을 수정할수도 있습니다.

예를 들어서 아래 단어들의 IDF값을 계산해볼게요. 전체 문서의 개수는 100개라고 가정할게요!

단어	등장한 문서 수DF(t)	전체 문서의 개수/DF(t)
돼지	90	90/100 = 1.11
늑대	50	100/50 = 2
벽돌집	10	100/10 = 10

많이 등장할수록 더 수치가 적은 것을 확인할 수 있습니다. 따라서 IDF를 정리하자면 희귀한 단어를 찾아내는 방법입니다.

그런데 수식에서 우리는 log를 빼고 계산했었죠. 이건 왜 씌우는 걸까요? 생각보다 아주 간단한 이유인데요.

아주 극단적으로 100개 문서중 1개의 문서에만 등장하는 단어, 그리고 100개 문서에 모두 등장하는 단어를 생각해볼게요.

전자는 100이 될테고, 후자는 1이 되겠죠. 값 차이가 너무 커지게 됩니다.

따라서 이러한 값이 너무 커지거나 작아지지 않게 log함수를 씌우게 됩니다.

TF-IDF

TF, IDF를 각각 알아봤으니 TF-IDF가 최종적으로 가지는 의미를 알아볼까요?

앞에서 계산했던, TF와 IDF를 곱하면 TF-IDF값을 얻을 수 있습니다.

TF는 단어가 얼마나 나오는지 알 수 있고, IDF는 단어가 얼마나 희귀한지 알 수 있습니다. 그럼 이 두 값을 곱한 TF-IDF는요?

바로 해석해 보자면 't 문서에서 많이 나오면서, 전체 문서에서 희소하게 나오는 단어'를 알 수 있습니다. 즉, t문서 내에서만 중요한 단어를 알 수 있는 것입니다.

예시를 한번 살펴볼게요. 전체 문서 개수는 100개, 해당 문서 내 단어 개수도 100개라고 가정해볼게요.

각각 문장, 문서에 등장하는 빈도수는 돼지-10/90, 늑대-6/50, 벽돌집 5/10입니다.

단어	TF	IDF	TF-IDF
돼지	10/100=0.10	log(100/90)=0.05	0.10x0.05=0.005
늑대	6/100=0.06	log(100/50)=0.3	0.06x0.3=0.018
벽돌집	5/100=0.05	log(100/10)=1.0	0.05x1.0=0.05

위의 결과로 봐서 이 문서는 '벽돌집'이 가장 중요한 단어라고 할 수 있습니다.

구현

그럼 이제 코드로 간단하게 구현해볼게요.

라이브러리 미사용

import math

# 예시 문서
documents = [
    "고양이는 귀엽다",
    "강아지는 충성스럽다",
    "고양이와 강아지는 친하다"
]

# 단어 목록 생성
def build_vocab(documents):
    vocab = set()
    for doc in documents:
        vocab.update(doc.split())
    return vocab

# TF 계산
def compute_tf(doc):
    tf_dict = {}
    words = doc.split()
    total_words = len(words)
    for word in words:
        tf_dict[word] = tf_dict.get(word, 0) + 1 / total_words
    return tf_dict

# IDF 계산
def compute_idf(documents, vocab):
    idf_dict = {}
    N = len(documents)
    for word in vocab:
        count = sum(1 for doc in documents if word in doc.split())
        idf_dict[word] = math.log(N / (1 + count))  # +1 to avoid division by zero
    return idf_dict

# TF-IDF 계산
def compute_tfidf(documents):
    vocab = build_vocab(documents)
    idf_dict = compute_idf(documents, vocab)
    
    tfidf_docs = []
    for doc in documents:
        tf_dict = compute_tf(doc)
        tfidf_doc = {word: tf_dict[word] * idf_dict.get(word, 0) for word in tf_dict}
        tfidf_docs.append(tfidf_doc)
    
    return tfidf_docs, vocab

# TF-IDF 계산 결과 출력
tfidf_docs, vocab = compute_tfidf(documents)
print("단어 목록:", vocab)
print("TF-IDF 결과:")
for idx, doc_tfidf in enumerate(tfidf_docs):
    print(f"문서 {idx + 1}: {doc_tfidf}")

라이브러리 사용

라이브러리를 사용하면 엄청 간단하게 이용할 수 있습니다.

from sklearn.feature_extraction.text import TfidfVectorizer

# 예시 문서
documents = [
    "고양이는 귀엽다",
    "강아지는 충성스럽다",
    "고양이와 강아지는 친하다"
]

# TfidfVectorizer 객체 생성
vectorizer = TfidfVectorizer()

# 문서에 대한 TF-IDF 계산
tfidf_matrix = vectorizer.fit_transform(documents)

# 결과 출력
print("단어 목록:", vectorizer.get_feature_names_out())
print("TF-IDF 행렬:\n", tfidf_matrix.toarray())

장단점

장점

단점

간단하고 직관적
- 계산이 쉽고 직관적이어서 구현하기 쉬움
- 문서의 특성을 반영한 단어 중요도 측정 가능
중요 단어를 효과적으로 추출
불필요 단어 필터링 가능
- 문서에서 흔한 단어를 제외할 수 있음(그리고, 하지만 등)
검색 엔진과 추천 시스템에서 유용
- 가장 관련있는 문서를 찾는 데 사용할 수 있음
- ex) 강아지 사료 추천 검색시 TF-IDF를 활용하여 관련 키워드가 가장 많이 포함된 문서를 상위에 노출시킬 수 있음

문맥을 반영하지 못함
- 개별 단어 빈도만 고려하고, 문맥이나 단어 순서 반영이 어려움
희소 행렬 문제
- 문서가 많아질수록 각 문서마다 등장하는 단어수가 적어지고, 대부분 0이 되는 희소 행렬이 생김
- ex) 1만 개의 문서에서 한 단어가 3개의 문서에만 등장하면, 대부분 값이 0인 행렬이 만들어져 메모리가 낭비할 수 있음
단어 길이나 변형을 고려하지 않음
- 먹다, 먹었다 등의 같은 의미의 단어가 다르게 취급됨
단어의 상대적인 중요도를 반영하지 못할 수 있음
- 매우 중요한 단어더라도 자주 등장하면 중요도가 낮아짐

때문에 TF-IDF는 문서에서 중요한 단어를 뽑고싶거나, 검색, 문서의 요약, 키워드 추출이 필요한 경우에 사용하시는 것을 추천드립니다.

사용하는 곳

사용처	설명
검색 엔진	TF-IDF를 이용하면 해당 키워드가 가장 중요하게 여겨지는 문서 검색을 할 수 있습니다. 위의 장점에도 적어두었지만 '강아지 사료 추천'검색시 관련 키워드가 가장 중요하게 여겨진 문서가 상위 노출되게 됩니다.
문서 분류	스팸 메일 분류와 같은 문서 분류에서도 높은 성능을 보이는데요. 스팸 문서에 자주 등장하는 단어가 특정 문서에서 중요도 높게 여겨진다면, 해당 메일은 스팸으로 분류할 수 있습니다.
텍스트 요약	뉴스에서 나온 핵심 단어를 추출하는 데 도움이 됩니다.
감성 분석	긍정적인 단어와 부정적인 단어가 중요하게 여겨진 문서를 찾아서, 긍정인지 부정인지 분류할 수 있습니다.
키워드 추출	텍스트 요약과 비슷하게 핵심 키워드를 찾아낼 수 있습니다.

이번 포스팅에서는 통계적 임베딩 방법인 TF-IDF에 대해 아주 자세하게 알아봤습니다.

다음 포스팅에서는 또 다른 통계적 임베딩 방법인 LSA에 대해 알아볼게요!

질문이나 의견 있으시면 언제든지 댓글 남겨주세요!

자연어처리 기초 토크나이저의 모든것! 종류부터 최신 트렌드까지!

컴공누나 — Sat, 8 Mar 2025 22:18:40 +0900

지난 포스팅에서는 자연어 처리가 무엇이고, 어떤 방법들이 있는지 정말 간단하게 알아봤습니다.

혹시 아직 자연어처리에 대한 개념이 잘 안잡혔다고 느껴지신다면,

아래의 포스팅을 먼저 보고 오시는 것을 추천드립니다.

자연어 처리 임베딩의 등장 배경과 종류

jaeyoon-95.tistory.com

이번 포스팅에서는 자연어 처리의 각 모델들에 대한 설명에 들어가기 전!

자연어 문장을 작은 단위인 토큰으로 나누는 과정들에 대해서 살펴볼까 합니다.

토크나이징 과정은 모든 모델들에 들어가기 전에 거쳐야하는 과정입니다.

그럼 오늘도 즐겁게 배워볼까요?!

토크나이저(Tokenizer)란?

지난 포스팅에서 자연어란 실생활에서 쓰는 사람의 언어라고 말씀드렸는데요. 컴퓨터가 이 자연어를 작업하기 위해서는 텍스트 데이터를 숫자로 표현해야하는데, 하나의 문장단위로 처리하기에는 어려움이 있습니다. 따라서 문장을 하나의 단어인 토큰 단위로 나누는 작업이 필요합니다. 즉, 토크나이저는 텍스트 데이터를 단어, 문장, 서브워드, 문자 등으로 나누는 도구라고 할 수 있습니다. 이 과정은 토크나이징 과정이라고하며, 토크나이저를 통해 얻어지는 것을 토큰이라고 부릅니다.

토크나이저는 굉장히 다양한 종류가있는데요. 가장 간단한 토크나이징 과정을 살펴볼게요.

예를 들어 "나는 자연어 처리를 공부하고 있어요"라는 문장을 입력받으면, 공백 기준으로 나누는 토크나이저는 "나는", "자연어", "처리를","공부하고","있어요"와 같은 토큰으로 나눌 수 있습니다.

이러한 토크나이징 과정을 잘한다면 불 필요한 기호, 조사, 불용어 등을 효과적으로 제거할 수 있고, 의미 있는 단어 단위로 모델이 학습할 수 있으며, 텍스트 데이터를 벡터화 하는 과정이 보다 쉬워집니다.

간단하게 정리하자면 "토크나이저는 컴퓨터가 이해하기 쉽게 자연어를 토큰 단위로 잘게 쪼개는 과정이다"로 생각해주시면 좋을 것 같습니다.

토큰이 잘 이해가 안돼요.
토큰을 너무 당연하게 얘기하고 넘어갔는데요. 조금 더 자세히 설명드려볼게요.
토큰이라는 것은 문장을 작은 단위로 나눈 것이라고 보시면 됩니다. 어떤 토크나이저로 나누냐에 따라 같은 문장이더라도 다른 토큰을 얻을 수 있는데요. "나는 자연어 처리를 공부하고 있어요"라는 문장으로 크게 두 가지 예를 들어볼게요.

1. 공백 단위로 나누는 방법
"나는", "자연어", "처리를", "공부하고", "있어요"

2. 글자 단위로 나누는 방법
"나","는","자","연","어","처","리","를","공","부","하","고","있","어","요"

각각의 토큰은 위와 같은 방법에 따라 달라질 수 있습니다.

토크나이저의 종류

토크나이저의 종류는 크게 전통 토크나이저와 서브워드 기반 토크나이저로 나눌 수 있습니다. 하나씩 자세하게 알아보도록 하겠습니다.

1. 전통적인 토크나이저

(1) 공백 기반 토크나이저(Whitespace Tokenizer)

이름에서도 알 수 있듯이 단순히 공백을 기준으로 문장을 나눕니다. 이 방법은 구현이 가장 간단하고 빠르지만, 한국어처럼 띄어쓰기가 중요한 언어에서는 성능이 굉장히 낮습니다. 또한 부호를 구분할 수 없기 때문에, ., !와 같은 특수문자도 문장에 포함됩니다.

예) "I am learning NLP." → ["I", "am", "learning", "NLP."]

(2) 문장부호 기반 토크나이저 (WordPunctTokenzer - NLTK)

단어와 문장부호를 따로 구분하여 토큰화를 하는 방법입니다. 이제는 문장 부호까지 정확하게 처리가 가능합니다. 특히 영어같은 언어에서는 꽤 효과적이라고하는데요. 한국어서는 여전히 적합하지 않습니다. 또 한가지 문제점은 don't와 같은 영어는 don, t 처럼 쪼개질 수 있습니다.

예) "I'm learning NLP!" → ["I", "'m", "learning", "NLP", "!"]

(3) 형태소 분석 기반 토크나이저(한국어 전용)

한국어는 조사, 어미 변형이 많기 때문에 단순히 공백만으로는 의미있는 토큰을 추출하기 어렵습니다. 따라서 한국어 특징에 맞게 형태소를 분속하여 분리하는 방식입니다. 특히 한국어, 일본어 등 형태소 중심인 언어에 최적화되어있고, 문맥을 고려하여 단어를 분리할 수 있습니다. 단, 언어별로 따로 모델을 학습해야하고, 속도가 느릴 수 있습니다. 토크나이저 종류로는 Mecab, Kkma, Hannanum, Okt등이 있고, 가장 빠르고, 많이 사용되는 형태소 분석기는 Mecab입니다. 실제로 KoBERT, 한국어 GPT에서도 사용됐다고 해요.

2. 서브워드 기반 토크나이저(Subword Tokenizer)

서브워드 기반 토크나이저는 위의 규칙 기반과는 다르게 사전에 다양한 문장으로 학습을 먼저 진행하고, 토크나이징 과정에서 학습된 토크나이저를 사용합니다.

(1) BPE(Byte Pair Encoding)

가장 빈번하게 등장하는 문자 쌍을 반복적으로 합치는 방식의 토크나이저입니다. 희귀한 단어를 작은 조각으로 나누고, 많이 쓰는 단어는 그대로 유지합니다. 다양한 단어를 토큰으로 만들 수 있지만, 어떤 데이터로 학습하냐에 따라서 굉장히 달라질 수 있고, 의미 없는 토큰이 생성될 수 있습니다. 이 방식은 GPT계열에 사용된 방법이며, 우리가 사용하는 ChatGPT도 BPE를 사용했다고 합니다.

예) "low", "lowest", "lower" → ["low", "er", "est"]

작동 과정은 아래 자세히 정리해 두었습니다.

작동 과정

1. 모든 단어를 문자 단위(Char Tokenization)로 분리

훈련 데이터에 "low", "lowest", "lower"가 있다고 가정할때, 다음과 같이 문자를 분해할 수 있음

["l", "o", "w"], ["l", "o", "w", "e", "s", "t"], ["l", "o", "w", "e", "r"]

2. 훈련 데이터에서 가장 많이 등장하는 문자 쌍 찾기

("l", "o") → 3번 등장
("o", "w") → 3번 등장
("w", "e") → 2번 등장

["lo", "w"], ["lo", "w", "e", "s", "t"], ["lo", "w", "e", "r"]

가장 많이 등장하는 문자 쌍 ("l", "o")를 먼저 병합

3. 같은 방식으로 반복 병합

["low"], ["low", "e", "s", "t"], ["low", "e", "r"]

BPE는 가장 자주 등장하는 문자 쌍을 반복적으로 병합하여 토큰을 생성

코드

from collections import defaultdict
import re

# 초기 단어 사전 (빈도 포함)
tokens = {"l o w": 5, "l o w e r": 2, "n e w e s t": 6, "w i d e s t": 3}

def get_stats(tokens):
    """토큰의 빈도를 계산하는 함수"""
    stats = defaultdict(int)
    for word, freq in tokens.items():
        symbols = word.split()
        for i in range(len(symbols) - 1):
            stats[(symbols[i], symbols[i+1])] += freq
    return stats

def merge_pair(pair, tokens):
    """가장 자주 등장하는 문자 쌍을 병합"""
    new_tokens = {}
    bigram = re.escape(' '.join(pair))
    pattern = re.compile(r'(?<!\S)' + bigram + r'(?!\S)')
    
    for word in tokens:
        new_word = pattern.sub(''.join(pair), word)
        new_tokens[new_word] = tokens[word]
    
    return new_tokens

# BPE 알고리즘 실행
num_merges = 5  # 병합 횟수 설정
for _ in range(num_merges):
    stats = get_stats(tokens)
    if not stats:
        break
    best_pair = max(stats, key=stats.get)
    tokens = merge_pair(best_pair, tokens)
    print(f"병합: {best_pair}, 현재 토큰: {tokens}")

(2) WordPiece

BPE와 비슷하지만 확률적으로 단어를 병합하는 방식입니다. 즉, 더 자주 등장하는 서브 워드를 우선적으로 합치는 방법입니다. 이 방식은 BPE보다 더 효율적인 방법이고, 희귀한 단어를 잘게 나누면서도, 의미있는 부분은 유지합니다. 하지만 모델을 학습하는 데 시간이 오래 걸리고, 새로운 도메인에서는 학습을 다시할 필요가 있습니다. 대부분 많은 BERT계열 모델에서 채택한 방법입니다.

예) "playing" → ["play", "##ing"] (##는 이어진다는 뜻)

작동 과정은 아래에 자세히 정리해 두었습니다.

작동 과정

1. 훈련 데이터에서 서브워드 확률 계산

playing
player
played
playful

각 서브워드의 빈도를 세어 확률을 계산 (MLE(Maximum Likelihood Estimation) 방식)

p("play") = 0.4   (4번 등장)
p("ing") = 0.2   (2번 등장)
p("er") = 0.1    (1번 등장)
p("ed") = 0.1    (1번 등장)
p("ful") = 0.1   (1번 등장)

각 서브워드의 확률 = 해당 서브워드가 등장한 횟수 / 전체 단어 개수

즉, "play"가 가장 높은 확률을 가지므로 가장 먼저 선택될 가능성이 높음

2. 확률이 높은 문자 쌍을 결합

훈련 데이터에서 서브워드 확률을 계산한 후, 확률이 높은 조합을 우선적으로 병합

["p", "l", "a", "y", "i", "n", "g"]  → 초기 상태
["play", "ing"]  → p("play") * p("ing") = 0.4 * 0.2 = **0.08**
["pla", "ying"]  → p("pla") * p("ying") = 0.1 * 0.05 = **0.005**
["playi", "ng"]  → p("playi") * p("ng") = 0.05 * 0.1 = **0.005**

가장 확률이 높은 조합이 ["play", "ing"]이므로 최종적으로 이 조합이 선택됨

3. 새로운 단어를 볼 때도 확률이 높은 서브워드 조합 선택

모델이 학습된 후에는, 새로운 단어가 들어왔을 때 최대 가능도(ML) 조합을 찾아 토큰화

예를 들어, "playings"라는 새로운 단어가 들어오면,

"play"와 "ing"이 가장 가능성이 높음 → 먼저 분해
"ing"과 "s"를 비교하여 "ing"을 유지하고 "s"를 추가

["play", "##ing", "##s"]

코드

import math

# 훈련 데이터에서 서브워드 확률 학습 (예제)
subword_probs = {
    "play": 0.4,
    "ing": 0.2,
    "er": 0.1,
    "ed": 0.1,
    "ful": 0.1
}

def wordpiece_tokenize(word, subword_probs):
    tokens = []
    start = 0
    while start < len(word):
        end = len(word)
        while start < end:
            subword = word[start:end]
            if subword in subword_probs:
                tokens.append(subword)
                start = end
                break
            end -= 1
        if subword not in subword_probs:
            tokens.append("[UNK]")  # 사전에 없는 단어 처리
            break
    return tokens

# 예제 실행
word = "playing"
tokens = wordpiece_tokenize(word, subword_probs)
print(f"WordPiece 결과: {tokens}")

(3) SentencePiece

BPE, WordPiece의 단점을 개선한 방식입니다. 앞의 BPE, Sentence Piece는 띄어쓰기가 있는 단어를 기준으로 하지만, Sentence Piece는 문장 전체를 분석하여 최적의 서브워드 조합을 학습합니다. 따라서 BPE, WordPiece보다 더 유연한 토큰화를 제공합니다. 단, 기존 방식보다 속도가 조금 느릴 수 있습니다.

예) "자연어처리는 정말 재미있어요!" → ["▁자연어", "처리", "는", "▁정말", "▁재미있어요", "!"]

작동 과정은 아래에 자세히 정리해 두었습니다.

작동 과정

1. 띄어쓰기 포함된 문장을 하나의 문자열로 변환

"자연어처리는 정말 재미있어요!"

2. 모든 문자 단위로 분리

처음에는 문장을 글자 단위로 나누고, 이를 기본 단위로 사용

['자', '연', '어', '처', '리', '는', '정', '말', '재', '미', '있', '어', '요', '!']

3. 가장 자주 등장하는 문자 쌍 찾기

가장 많이 등장하는 문자 조합을 학습해서 서브워드를 생성함

이 과정은 BPE와 비슷하지만, 확률적으로 최적의 서브워드를 선택하는 것이 차이

예를 들어, 훈련 데이터에서 "자연어"라는 단어가 많이 등장한다고 한다면,

'자연'  → 3번 등장  
'연어'  → 3번 등장  
'처리'  → 2번 등장

가장 많이 등장한 ('자', '연')과 ('연', '어')를 먼저 병합

4. 서브워드 병합 진행

['자연어', '처', '리', '는', '정', '말', '재', '미', '있', '어', '요', '!']

"자연어"가 하나의 서브워드로 병합됨

5. 확률적으로 최적의 서브워드 조합 선택

SentencePiece는 단순 빈도 기반 병합이 아니라, 각 서브워드의 확률을 계산해서 가장 가능성이 높은 조합을 선택

예를 들어, "재미있어요"가 훈련 데이터에서 많이 등장했다면

['자연어', '처', '리', '는', '정', '말', '재미있어요', '!']

"재미있어요"가 하나의 서브워드로 유지

코드

import re
from collections import defaultdict

# 1️. 훈련용 데이터
corpus = [
    "나는 자연어처리를 좋아해.",
    "자연어처리는 어려워 보이지만 재미있어.",
    "딥러닝과 머신러닝을 활용해서 자연어를 이해할 수 있어.",
    "자연어 모델은 사람처럼 문장을 분석해."
]

# 2️. 문자 단위로 데이터 분할
tokens = []
for sentence in corpus:
    sentence = re.sub(r"[\.\!\?]", "", sentence)  # 문장부호 제거
    tokens.extend(list(sentence))  # 글자 단위로 나누기

# 3️. 초기 서브워드 사전 생성
subwords = defaultdict(int)
for token in tokens:
    subwords[token] += 1

# 4️. 가장 자주 등장하는 문자 쌍을 병합
def get_most_frequent_pair(subwords):
    """ 가장 빈도 높은 문자 쌍 찾기 """
    pairs = defaultdict(int)
    subword_list = list(subwords.keys())
    
    for i in range(len(subword_list) - 1):
        pair = (subword_list[i], subword_list[i + 1])
        pairs[pair] += subwords[subword_list[i]] + subwords[subword_list[i + 1]]
    
    return max(pairs, key=pairs.get, default=None)

# 5. 병합 수행
num_merges = 5  # 병합 횟수
for _ in range(num_merges):
    pair = get_most_frequent_pair(subwords)
    if pair is None:
        break
    
    merged_token = "".join(pair)
    subwords[merged_token] = subwords.pop(pair[0]) + subwords.pop(pair[1])
    print(f"병합: {pair} → {merged_token}")

# 6️. 문장 토크나이징
def tokenize(sentence, subwords):
    """ 학습된 서브워드를 이용하여 문장 토크나이징 """
    for subword in sorted(subwords.keys(), key=len, reverse=True):
        sentence = sentence.replace(subword, f" {subword} ")
    return sentence.split()

# 7️. 테스트 실행
test_sentence = "나는 자연어처리를 공부하고 있어."
tokenized_sentence = tokenize(test_sentence, subwords)
print("  SentencePiece 토큰화 결과:", tokenized_sentence)

정리

한국어처럼 형태소 분석이 중요한 언어는 Mecab과 같은 전통적인 방법도 여전히 많이 사용하는 추세입니다.

최근 트렌드 같은 경우는 서브워드 기반(특히 BPE)으로 많이 넘어갔고, 딥러닝을 활용한 토크나이저가 주목을 받고 있다고 합니다.

토크나이저	방식	특징	사용 모델
BPE	가장 자주 등장하는 문자 쌍 병합	희귀 단어도 처리 가능하지만 불규칙한 경우 발생	GPT-3, GPT-4
WordPiece	확률적으로 병합할 단어 선택	빈도가 아니라 가능성이 높은 서브워드 병합	BERT, RoBERTa
SentencePiece	띄어쓰기 없이 문장을 직접 학습	한국어, 일본어 등 다국어 지원	T5, XLNet

이번 포스팅은 자연어 처리에 필요한 토크나이저에 대해 알려드렸는데요.

다음 포스팅부터는 자연어를 임베딩 할 수 있는 모델에 대해 하나씩 자세하게 알려드릴게요!

다음 포스팅에서 만나요~

자연어 처리 임베딩의 등장 배경과 종류

컴공누나 — Thu, 6 Mar 2025 22:38:38 +0900

어느 순간부터 딥러닝이 점점 핫해지기 시작했는데요.

OpenAI의 ChatGPT가 공개되면서 LLM에 대한 관심이 폭주하기 시작했어요.

이번 포스팅 시리즈는 초기 LM부터 LLM까지 자연어 처리 모델이 어떻게 진화해 왔는지 그 과정을 살펴보려고해요.

오늘은

1. 자연어 처리가 무엇인지

2. 임베딩이 왜 필요한지

3. 어떤 방법론들이 제시되어있고, 특징은 무엇인지

크게 세 포인트로 알아볼게요.

그리고 이후에는 각 임베딩 방법론들을 자세히 알아보며 LLM까지 한번 이해해보도록 하겠습니다.

그럼 시작해볼게요!

자연어 처리(NLP)란 무엇인가?

사람들은 일상에서 대화할 때 언어를 이용하죠. 이것을 바로 '자연어'라고 부르는데요.

반면 컴퓨터는 숫자만 이해할 수 있기 때문에 인간의 언어를 직접 처리하기는 어렵습니다.

이때, 컴퓨터가 자연어를 이해하고 해석하며, 문장을 생성할 수 있도록 돕는 기술을 자연어 처리(Natural Language Processing)라고 합니다.

즉, 자연어 처리는 컴퓨터가 인간의 언어를 효과적으로 다룰 수 있도록 만드는 기술 분야입니다.

임베딩이란 무엇인가?

임베딩은 위에서 말씀드린 '자연어'를 컴퓨터가 잘 이해할 수 있는 의미있는 '숫자'로 바꿔주는 방법입니다.

예를 들어 "안녕하세요" 를 [66.3, 0.33, 5.33] 등의 숫자로 바꿔줍니다.

초기에는 정말 단순한 원-핫 벡터(one-hot vector)라는 방법으로 표현했지만, 단어 간의 의미를 반영하지 못하고, 벡터의 차원만 커지는 문제가 있었습니다. 이를 해결하기 위해 벡터 공간에 임베딩하여 반영하려는 연구가 등장했습니다.

임베딩은 자연어 처리만 있나요?
임베딩은 어떤 데이터를 더 의미있는 표현 공간으로 변환하는 과정을 의미합니다. 따라서 이미지, 영상, 보이스 등의 다른 데이터들을 임베딩하여 벡터 공간에 의미있는 벡터로 표현을 할 수 있습니다. 위에서 말씀 드렸듯이 이렇게 표현하는 이유는 컴퓨터가 잘 알아듣게 하기 위함입니다.
여기서는 자연어 처리에서의 임베딩만 다룰 예정입니다.

임베딩의 종류

임베딩은 정말 다양한 방법론들이 제안되었는데요. 이 제안된 방법론들은 크게 3가지의 카테고리로 나눌 수 있습니다.

첫 번째는 단순 빈도 기반으로하는 통계적 임베딩, 두 번째는 단어 벡터를 학습해서 사용하는 정적 임베딩, 마지막으로는 문맥을 반영하여 의미 변화 처리가 가능한 동적 임베딩입니다. 간단하게 하나씩 살펴볼게요.

1. 통계적 임베딩

초기 자연어 임베딩 방법론들은 정말 간단하게 단어의 빈도수를 기반으로 임베딩했습니다.

크게는 TF-IDF, LSA, LDA 등이 있는데요. 간단하게 그 모델들의 특징을 살펴보면 다음과 같습니다.

하나씩 차근차근 포스팅할 예정이니 여기서 다 이해하실 필요는 없습니다.

방법론	방식	문제
TF-IDF	단어 빈도 x 역문서 빈도 사용	단어 순서를 고려하지 않고, 희소 벡터 발생
LSA	단어-문서 행렬에 특이값 분해를 적용하여 차원 축소	단어 순서나 문맥을 반영하지 못함
LDA	단어를 확률적 토픽 분포로 모델링	문장 내 단어 순서를 반영하지 않음

통계적 임베딩 방법은 단순 빈도 기반의 방식이라 단어의 의미나 문맥을 반영하기 어렵다는 한계점이 있습니다.

2. 정적 임베딩

통계적 임베딩 보다 한 단계 더 발전한 임베딩 방법인데요. 단어 간의 유사도를 반영하면서 '고정된 벡터'를 제공하는 방식입니다.

즉, 특정 단어에 대한 임베딩이 정해져있는 것이죠. 때문에, 문맥에 따라 달라지는 단어의 의미를 잘 반영하지는 못합니다.

방법론	방식	문제
Word2Vec	- CBOW : 주변 단어 -> 중심 단어 예측 - Skip-gram : 중심 단어 -> 주변 단어 예측	동일한 단어는 항상 같은 벡터를 가짐
GloVe	통계적인 방법과 Word2Vec의 결합	여전히 문맥을 반영하지 못함
FastText	단어를 Subword단위로 분해하여 학습	여전히 문맥을 고려하지 못함

단어 의미를 잘 반영하지만, 문맥을 고려하지 못하는 한계점은 여전히 남아있습니다.

3. 동적 임베딩

정적 임베딩의 한계를 해결하기 위해 문맥을 반영하는 임베딩이 등장했습니다.

요즘 핫한 LLM도 결국 동적 임베딩으로 임베딩을 한 뒤, 자연어를 처리합니다.

방법론	방식	문제
ELMo	BiLSTM 기반의 모델	LSTM기반이라 긴 문장에서 성능 저하
BERT	Transformer기반 양방향 학습 문맥에 따라 단어 벡터가 다르게 변함	계산량이 많고 느림
GPT	Transformer 기반 단방향 학습 주어진 문맥에서 다음 단어를 예측하는 방식	문맥을 한 방향에서만 보기 때문에 한계 존재
T5/BART	문장 전체를 재구성하는 방식 번역, 요약, 문서 생성 등 다양한 태스크 수행 가능	계산량이 많고 느림

현재는 자연어 처리의 임베딩은 동적 임베딩까지 발전하면서 단어의 의미 뿐만 아니라 문맥까지도 잘 고려해냅니다.

하지만 그 만큼 계산량이 굉장히 많은데요. 따라서 계산량, 비용을 줄이는 연구도 활발히 진행되고 있습니다.

최근에는 ChatGPT 대비 비용이 굉장히 저렴한 딥시크가 등장해서 핫 이슈였죠.

임베딩시 고려해야 할 것
임베딩이 언어를 숫자로 표현해주는 것이라고 단순하게 말할 수 있는데요. "그럼 그냥 숫자로 변환해주면 되는거 아닌가? 왜이렇게 방법이 많지?" 생각이 드실 수 있어요. 예를들어 좋아해는 10, 싫어해는 11, 사랑해는 12라고 해봅시다. 현실에서 좋아해는 싫어해보다 사랑해와 거리가 가까워야하는데요. 이렇게 되면 싫어해와 더 가까워지죠. 물론 싫어해를 12, 사랑해를 11로 정의하면 가까워지긴 하겠지만, 이걸 모든 언어에 수동으로 적용시키기에는 한계가 있습니다. 뿐만 아니라 '영희가 사과를 먹는다.'와 '영희가 사과를 했다'의 사과는 다른 의미를 지니는데요. 하나의 수치로 정해버리면 두 사과가 같은 의미로 인식됩니다. 따라서 문맥에 따라 다르게 인식할 수 있게 임베딩 해야겠죠.

전자의 좋아해, 싫어해 예시는 어떤 단어끼리 더 연관있고, 가까운지 '단어의 의미'를 고려해야하고, 후지의 사과 예시는 '문맥'을 잘 반영해야합니다. 이것이 임베딩시 고려해야할 것들입니다.

카테고리	기법	문맥 반영	단점
통계적 임베딩	TF-IDF, LSA, LDA	X	단어 순서, 의미 반영 불가
정적 임베딩	Word2Vec, GloVe, FastText	X	문맥 반영 불가, 다의어 처리 불가
동적 임베딩	ELMo, BERT, GPT, T5	O	계산랑 크고, 비용 높음

이번 포스팅에서는 자연어 처리의 기본 개념과 임베딩의 필요성에 대해서 알아봤는데요.

여기서 언급되었던 임베딩 모델들은 추후 포스팅에서 하나씩 자세하게 다룰 예정입니다.

앞으로 포스팅도 많이 기대해주세요!

질문과 의견은 언제든 환영입니다.

파이썬 기초 강의 3강 파이썬의 자료구조

컴공누나 — Wed, 5 Mar 2025 21:30:15 +0900

지난 포스팅에서는 파이썬의 변수와 기초 자료형에 대해서 알아봤는데요.

만약 자료형이 뭔지 모르신다면 앞의 포스팅 먼저 보시는 것을 추천드려요.

파이썬 기초 강의 2강 변수와 데이터 타입

지난 포스팅에서는 파이썬이 무엇이고 왜 배워야하는지 알려드렸습니다.만약 앞의 포스팅을 못보셨다면 먼저 보고 오시는 것을 추천드립니다. 파이썬 기초 강의 1강 파이썬이란?요즘 정말 핫

jaeyoon-95.tistory.com

이번 포스팅에서는 조금 더 심화된 파이썬의 자료구조에 대한 이야기를 해볼까 합니다.

끝까지 잘 따라와주시면 너무 좋을 것 같아요!

질문은 언제나 환영입니다.

자료구조란 무엇인가?

자료구조란 데이터를 효율적으로 저장하고 관리하는 하나의 방법을 의미하는데요.

파이썬에서는 이러한 자료 구조를 기본으로 제공합니다.

크게 리스트, 튜플, 딕셔너리, 셋 이렇게 네 가지로 분류할 수 있습니다.

자료구조	설명	예시
List	여러 개의 값을 저장할 수 있는 순서가 있는 자료형(수정 가능)	[“컴공누나”]
Tuple	여러 개의 값을 저장할 수 있는 순서가 있는 자료형(수정 불가)	(“컴공누나”)
Dictionary	키(key)와 값(value) 쌍으로 이루어진 자료형	{“name”:”컴공누나”}
Set	중복을 허용하지 않는 자료형	{“컴공누나”}

이제 위의 자료구조를 하나씩 살펴볼게요.

리스트(List)

리스트는 다양한 형태의 자료형을 저장할 수 있습니다.

저장된 데이터들은 순서가 존재하는데요. 때문에 index로 접근을 할 수 있습니다.

값의 추가, 수정, 삭제가 가능해서 비교적 자유로운 자료 구조라고 할 수 있습니다.

대괄호 []를 이용하여 데이터를 감싸는 형태로 정의하게 됩니다.

# 리스트 생성
fruits = ["사과", "바나나", "딸기"]
print(fruits)  # ['사과', '바나나', '딸기']

# 요소 접근 (인덱싱)
print(fruits[0])  # '사과'
print(fruits[-1])  # '딸기' (음수 인덱스 사용 가능)

# 리스트 값 변경
fruits[1] = "오렌지"
print(fruits)  # ['사과', '오렌지', '딸기']

# 요소 추가
fruits.append("포도")  # 끝에 추가
fruits.insert(1, "망고")  # 특정 위치에 추가
print(fruits)  # ['사과', '망고', '오렌지', '딸기', '포도']

# 요소 삭제
fruits.remove("딸기")  # 특정 값 제거
del fruits[0]  # 특정 인덱스 삭제
print(fruits)  # ['망고', '오렌지', '포도']

# 리스트 길이 확인
print(len(fruits))  # 3

앞의 포스팅에서 설명했던 자료형처럼 자료구조도 사용 가능한 연산자들이 있습니다.

단순히 +, *도 있지만, append()등의 함수도 있죠.

사용되는 코드는 아래의 예제에서 확인해볼게요!

# 리스트 생성
my_list = [3, 1, 4, 1, 5]

my_list = my_list + [9, 2, 6]  # [3, 1, 4, 1, 5, 9, 2, 6]
my_list = my_list * 2  # [3, 1, 4, 1, 5, 9, 2, 6, 3, 1, 4, 1, 5, 9, 2, 6]
len(my_list)  # 16
my_list.append(5)  # [3, 1, 4, 1, 5, 9, 2, 6, 3, 1, 4, 1, 5, 9, 2, 6, 5]
my_list.insert(2, 8)  # [3, 1, 8, 4, 1, 5, 9, 2, 6, 3, 1, 4, 1, 5, 9, 2, 6, 5]
my_list.remove(1)  # [3, 8, 4, 1, 5, 9, 2, 6, 3, 1, 4, 1, 5, 9, 2, 6, 5]
popped_value = my_list.pop()  # popped_value = 5
index_of_4 = my_list.index(4)  # index_of_4 = 2
count_of_1 = my_list.count(1)  # count_of_1 = 2
my_list.sort()  # [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 8, 9, 9]
my_list.reverse()  # [9, 9, 8, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1]

덧셈의 경우 단순히 두 리스트를 이어 붙이는 것을 알 수 있습니다.

곱셈의 경우 곱해진 수만큼 해당 리스트가 반복됩니다.

len의 경우 리스트 길이를 측정하는 함수로, len(A)처럼 사용합니다. A는 길이를 측정할 대상인 리스트입니다.

append(A)는 내에 있는 숫자 A는 리스트의 가장 마지막 부분에 추가됩니다.

insert(A, B)의 경우 A의 자리에 B의 값이 추가됩니다.

위의 예제는 인덱스 2번째 자리에 10이 추가된 것을 확인할 수 있죠.

remove(A)는 리스트 내에서 A의 값을 삭제해 줍니다. 단, 가장 앞에 있는 1개만 삭제됩니다.

pop()은 리스트의 가장 마지막에 있는 원소를 꺼내줍니다. 꺼내고 나면 리스트에 해당 값은 삭제됩니다.

index(A)는 리스트 내에 있는 A값의 인덱스를 찾는 함수입니다. 여러개일 경우 가장 첫 번째 값의 인덱스를 반환합니다.

count(A)는 리스트 내에 있는 숫자 A의 개수를 세줍니다.

sort()는 말 그대로 리스트를 정렬시켜주는데요.

오름차순의 경우 그대로 두시면 되고, 내림차순은 sort(reverse=True)로 사용 가능합니다.

reverse()는 현재 리스트를 반대로 뒤집는 함수입니다.

튜플(Tuple)

튜플은 리스트와 비슷하게 사용되지만, 굉장히 다른 자료구조입니다.

튜플은 값의 변경 자체가 불가능합니다. 따라서 데이터를 보호가 필요할 경우 사용됩니다.

한 가지 동일한 점은 값의 순서가 있기 때문에 index접근이 가능하다는 것입니다.

두 자료구조의 속도를 비교하자면 튜플이 조금 더 빠릅니다.

튜플은 소괄호 ()를 이용하여 데이터를 감싸는 형태로 정의합니다.

# 튜플 생성
colors = ("빨강", "초록", "파랑")
print(colors)  # ('빨강', '초록', '파랑')

# 요소 접근 (인덱싱)
print(colors[1])  # '초록'

# 값 변경 시도 (오류 발생)
# colors[1] = "노랑"  # ❌ TypeError: 'tuple' object does not support item assignment

# 요소 개수 확인
print(len(colors))  # 3

# 튜플에서 특정 값의 개수 찾기
print(colors.count("빨강"))  # 1

위의 코드 예시에서 보시는 것 처럼 특정 값을 인덱스로 접근한 뒤 수정하려고하면 타입 에러가 납니다.

이제 튜플에서 사용 가능한 연산자를 살펴볼게요.

튜플은 비교적 간단한 연산자들이 있습니다.

# 튜플 생성
my_tuple = (3, 1, 4, 1, 5)

my_tuple = my_tuple + (9, 2, 6)  # (3, 1, 4, 1, 5, 9, 2, 6)
my_tuple = my_tuple * 2  # (3, 1, 4, 1, 5, 9, 2, 6, 3, 1, 4, 1, 5, 9, 2, 6)
len(my_tuple)  # 16
index_of_4 = my_tuple.index(4)  # index_of_4 = 2
count_of_1 = my_tuple.count(1)  # count_of_1 = 3

덧셈의 경우 위의 리스트랑 역할이 같습니다. 다른 튜플과 합해줍니다.

곱셉 연산자 같은 경우 리스트와 동일하게 반복해줍니다.

len(A)도 동일하게 길이를 측정해주는 함수인데, A가 Tuple입니다.

index(A)는 튜플 내 특정 값 A의 인덱스를 찾아줍니다. 여러 개 있을 경우 첫 번째 값의 위치를 반환합니다.

count(A)의 경우 튜플 내에 있는 A의 개수를 세줍니다.

딕셔너리(Dictionary)

키(Key)와 값(Value) 쌍으로 저장하는 자료구조입니다.

기존 리스트와 튜플과는 굉장히 다른 형태인데요. 가장 큰 차이점은 딕셔너리는 순서가 없다는 것입니다.

딕셔너리의 Key값은 중복될 수 없지만, Value는 중복될 수 있습니다.

딕셔너리 내에 있는 값들은 언제든지 수정 및 삭제할 수 있습니다.

표현 방법은 {Key:Value}입니다.

# 딕셔너리 생성
student = {"이름": "철수", "나이": 20, "학교": "파이썬고"}
print(student)  # {'이름': '철수', '나이': 20, '학교': '파이썬고'}

# 특정 값 조회
print(student["이름"])  # '철수'

# 값 변경
student["나이"] = 21  
print(student)  # {'이름': '철수', '나이': 21, '학교': '파이썬고'}

# 새로운 키-값 추가
student["전공"] = "컴퓨터"
print(student)  # {'이름': '철수', '나이': 21, '학교': '파이썬고', '전공': '컴퓨터'}

# 키 삭제
del student["학교"]
print(student)  # {'이름': '철수', '나이': 21, '전공': '컴퓨터'}

# 딕셔너리의 모든 키와 값 조회
print(student.keys())  # dict_keys(['이름', '나이', '전공'])
print(student.values())  # dict_values(['철수', 21, '컴퓨터'])

위와 같이 초기 student 딕셔너리를 선언하고, 언제든지 특정 키에 대한 값을 변경할 수 있으며 추가, 삭제가 자유롭습니다.

이제 딕셔너리에서 사용 가능한 연산자를 살펴보겠습니다.

앞에서 못봤던 함수들이 굉장히 많죠.

# 딕셔너리 생성
my_dict = {"a": 1, "b": 2, "c": 3}

# len() : 딕셔너리 길이 반환 (키 개수)
len(my_dict)  # 3
"a" in my_dict  # True
"x" in my_dict  # False
my_dict.keys()  # dict_keys(['a', 'b', 'c'])
my_dict.values()  # dict_values([1, 2, 3])
my_dict.items()  # dict_items([('a', 1), ('b', 2), ('c', 3)])
my_dict.get("b")  # 2
my_dict.get("x")  # None / 없는 키일 경우 None 반환
my_dict.get("x", "기본값")  # "기본값" / key가 없으면 "기본값"반환
popped_value = my_dict.pop("b")  # popped_value = 2
my_dict.update({"d": 4, "e": 5})  # my_dict = {'a': 1, 'c': 3, 'd': 4, 'e': 5}
my_dict.clear()  # my_dict = {}

len(A) 같은 경우 앞의 리스트, 튜플과 같은데요. 딕셔너리 A의 key-value쌍이 몇개인지 숫자를 세줍니다. A는 딕셔너리 입니다.

in은 함수가 아니고, 단순 key값이 포함되어 있는지 찾기 위해 사용합니다. 왼쪽은 찾고자 하는 key, 오른쪽엔 딕셔너리를 적으시면 됩니다.

keys()는 딕셔너리에 있는 모든 key값들을 반환합니다.

values()는 딕셔너리 내에 있는 모든 value값들을 반환합니다.

items()는 딕셔너리 내에 있는 key, value쌍을 반환합니다.

get(A)는 딕셔너리 내에 A라는 키값이 있는지 확인하고 그 값을 반환해줍니다. 없을 경우 None을 반환합니다.

pop(A)는 A라는 키를 가진 값을 반환하고, 기존 딕셔너리에서 삭제시켜줍니다.

update(A)는 A라는 딕셔너리를 기존 딕셔너리에 추가해줍니다.

clear()는 딕셔너리를 비워줍니다.

세트(Set)

세트도 기존과는 살짝 다른 성질을 띄는 자료구조입니다.

세트는 순서가 없으며 값들을 추가, 삭제할 수 있는데요.

주의할 점은 순서가 없기 때문에 index로 접근이 불가능합니다.

특이한 점은 중복해서 저장이 되지 않는다는 것입니다.

마치 하나의 집합처럼 사용할 수 있고, 실제로 집합 연산자를 사용하실 수 있습니다.

# 세트 생성
numbers = {1, 2, 3, 3, 4, 5, 5}
print(numbers)  # {1, 2, 3, 4, 5} (중복 제거됨)

# 요소 추가
numbers.add(6)
print(numbers)  # {1, 2, 3, 4, 5, 6}

# 요소 삭제
numbers.remove(2)
print(numbers)  # {1, 3, 4, 5, 6}

# 집합 연산
A = {1, 2, 3}
B = {3, 4, 5}
print(A | B)  # 합집합: {1, 2, 3, 4, 5}
print(A & B)  # 교집합: {3}
print(A - B)  # 차집합: {1, 2}

간단하게 추가, 삭제가 가능하고, 집합 연산자들을 모두 사용할 수 있죠.

세트에서 사용할 수 있는 연산자들도 살펴볼게요.

새로운 함수들이 많이 등장했네요.

# 세트 생성
my_set = {1, 2, 3, 4, 5}

len(my_set)  # 5
3 in my_set  # True
10 in my_set  # False
my_set.add(6)  # {1, 2, 3, 4, 5, 6}
my_set.remove(3)  # {1, 2, 4, 5, 6} KeyError 발생 (주의!)
my_set.discard(10)  # {1, 2, 4, 5, 6} (변화 없음)
popped_value = my_set.pop()  # popped_value = 1 (세트라서 임의의 값이 제거됨)
my_set.clear()  # my_set = set()

# 새로운 세트 생성
set1 = {1, 2, 3}
set2 = {3, 4, 5}

# union() : 합집합 (set1 ∪ set2)
set1.union(set2)  # {1, 2, 3, 4, 5}
# intersection() : 교집합 (set1 ∩ set2)
set1.intersection(set2)  # {3}
# difference() : 차집합 (set1 - set2)
set1.difference(set2)  # {1, 2}
set2.difference(set1)  # {4, 5}

len(A)의 경우 세트 A의 길이를 측정해줍니다.

in의 경우 마찬가지로 왼쪽의 값이 오른쪽의 세트에 있는지 체크해줍니다.

add(A)의 경우 세트에 값 A를 추가해줍니다.

remove(A)는 세트에 A값이 있을 경우 삭제해주고, 없으면 KeyError를 발생시킵니다.

discard(A)는 세트에 A값이 있을 경우 삭제해주고, 없을 경우 무시합니다.

pop()은 세트의 값을 무작위로 삭제시킵니다.

clear는 세트를 초기화합니다.

B.union(A)은 합집합으로 두 세트 A,B의 합집합을 구해줍니다.

B.intersection(A)는 두 세트 A,B의 교집합을 구해줍니다.

A.difference(B)는 두 세트 A,B의 차집합을 구해줍니다.

정리

지금까지 파이썬의 자료구조형인 리스트, 튜플, 딕셔너리, 세트에 대해 알아봤습니다.

이 자료구조형들은 그럼 언제 쓰는게 적합할까요?

간단하게 아래의 상황속에서 사용할 수 있을 것 같습니다.

상황	자료구조형
자료형에 순서가 필요한 경우	List, Tuple
값의 변경이 필요한 경우	List
변경하면 안되는 고정값인 경우	Tuple
Key로 데이터를 관리할 경우	Dictionary
중복을 제거가 필요한 경우	Set

앞으로 더 많은 예제에서 다뤄볼 예정이니, 당장 헷갈린다고 해도 너무 걱정마세요!

그럼 다음 포스팅에서 만나요~