R, Python 분석과 프로그래밍의 친구 (by R Friend)

토큰화, 단어 임베딩, 텍스트 임베딩은 자연어 처리(NLP) 및 기계 학습에서 텍스트 데이터를 표현하고 처리하는 데 사용되는 개념입니다. 이러한 개념들은 감정 분석, 기계 번역, 텍스트 분류와 같은 NLP 작업에서 중요하며, 기계 학습 모델이 이해하고 학습할 수 있는 형태로 텍스트 정보를 표현하고 처리하는 데 사용됩니다.

이번 포스팅에서는 토근화(Tokenization), 단어 임베딩 (Word Embedding), 텍스트 임베딩 (Text Embedding)에 대해서 소개하겠습니다. 그리고 transformers 와 PyTorch 를 이용하여 실습을 해보겠습니다. 

1. 토큰화 (Tokenization)

- 정의: 토큰화는 텍스트를 토큰이라 불리는 더 작은 단위로 분해하는 과정입니다. 이러한 토큰은 단어, 서브워드 또는 문자일 수 있으며 원하는 정밀도 수준에 따라 다릅니다.

- 목적: 토큰화는 NLP에서 중요한 전처리 단계로, 기계가 텍스트의 개별 요소를 이해하고 처리할 수 있게 합니다. 토큰은 후속 분석을 위한 구성 요소로 작용합니다.

-- Install transformers, torch, sentence-transformers at terminal at first 

pip install -q transformers
pip install -q torch
pip install -q -U sentence-transformers

# 1. Tokenization 
# : Tokenization is the process of breaking down a text into smaller units called tokens. 
# : These tokens can be words, subwords, or characters, depending on the level of granularity desired.

from transformers import AutoTokenizer

# Load pre-trained DistilBERT tokenizer
tokenizer = AutoTokenizer.from_pretrained('distilbert-base-uncased')

# Example text
text = "Love is wanting to be loved"

# Tokenize the text
input_ids = tokenizer.encode(text)
tokens = tokenizer.tokenize(tokenizer.decode(input_ids))

print("Input IDs:", input_ids)
print("-------" * 10)
print("Tokens:", tokens)

# Input IDs: [101, 2293, 2003, 5782, 2000, 2022, 3866, 102]
# ----------------------------------------------------------------------
# Tokens: ['[CLS]', 'love', 'is', 'wanting', 'to', 'be', 'loved', '[SEP]']

2. 단어 임베딩 (Word Embedding)

- 정의: 단어 임베딩은 단어를 연속적인 벡터 공간의 실수로 이루어진 밀도 있는 벡터로 나타내는 기술입니다. 각 단어는 벡터로 매핑되며 이러한 벡터 간의 거리와 방향이 의미를 가집니다.

- 목적: 단어 임베딩은 단어 간의 의미적 관계를 포착하여 기계가 주어진 텍스트의 맥락과 의미를 이해할 수 있게 합니다. 단어가 맥락과 의미가 유사한 경우 단어 임베딩 벡터가 서로 가깝게 위치하는 특성이 있어 semantic search에 유용하게 활용됩니다. 유명한 단어 임베딩 모델로는 Word2Vec, GloVe, FastText가 있습니다. 

# 2. Word Embedding
# : Word embedding is a technique that represents words 
#   as dense vectors of real numbers in a continuous vector space. 
# : Each word is mapped to a vector, and the distances and directions 
#   between these vectors carry semantic meaning.

from transformers import AutoTokenizer, AutoModel
import torch

# Load pre-trained DistilBERT model
tokenizer = AutoTokenizer.from_pretrained('distilbert-base-uncased')
model = AutoModel.from_pretrained('distilbert-base-uncased')

# Encode the tokens to obtain word embeddings
input_ids = tokenizer.encode(text, return_tensors='pt')
with torch.no_grad():
    word_embeddings = model(input_ids)[0]

print("Tensor Size:", word_embeddings.size())
print("------" * 10)
print("Word Embeddings:")
print(word_embeddings)
# Tensor Size: torch.Size([1, 8, 768])
# ------------------------------------------------------------
# Word Embeddings: 
#   tensor([[
#          [-0.1067, -0.0101, -0.0897,  ..., -0.1721,  0.2134,  0.3274],
#          [ 0.8698,  0.1002,  0.2687,  ..., -0.3276,  0.4205,  0.1344],
#          [-0.1877, -0.0777,  0.1905,  ..., -0.0220,  0.0024,  0.5138],
#          ...,
#          [ 0.5998, -0.2141,  0.3774,  ..., -0.3945, -0.1149,  0.1245],
#          [ 1.1550, -0.1050,  0.3570,  ..., -0.4063, -0.0489, -0.0717],
#          [ 1.0036,  0.1886, -0.4508,  ...,  0.0999, -0.5486, -0.3076]]])

3. 텍스트 임베딩 (Text Embedding)

- 정의: 텍스트 임베딩은 문장(sentences)이나 문서(documents) 전체를 밀도 있는 벡터로 나타내어 전체 텍스트의 전반적인 의미를 캡처하는 기술입니다. 단어 임베딩을 집계하거나 요약하여 전체 텍스트의 표현을 만듭니다. 

- 목적: 텍스트 임베딩은 전체 문서나 문장을 의미적 공간에서 비교하고 분석할 수 있게 합니다. 텍스트 임베딩을 생성하는 방법에는 단어 임베딩의 평균(averaging word embeddings)을 사용하거나 순환 신경망(RNN), 장·단기 기억 네트워크(LSTM), 트랜스포머(Transformers)를 사용하는 방법 등이 있습니다. 

텍스트 임베딩은 

 - 텍스트 분류 (Text Classification),

 - 감성분석 (Sentiment Analysis),

 - 검색 엔진 랭킹 (Search Engine Ranking),

 - 군집 및 유사도 분석 (Clustering and Similarity Analysis),

 - 질의 응답 (Question Answering, 질문과 답변을 임베딩으로 표현함으로써 시스템은 쿼리의 의미 콘텐츠와 데이터셋의 관련 정보를 정확하게 검색할 수 있음)

등에 활용할 수 있습니다. 

text embedding 을 하는 방법에는 (1) transformers 를 이용한 방법과, (2) sentence-transfomers 모델을 이용하는 방법이 있습니다. sentence-transformers 모델을 이용하는 방법이 코드가 간결합니다. 

3-1. transformers 를 이용한 text embedding

# 3. Text Embedding
# : Text embedding represents entire sentences or documents as dense vectors, 
#   capturing the overall meaning of the text. 
# : It involves aggregating or summarizing word embeddings 
#   to create a representation for the entire text.

from transformers import AutoTokenizer, AutoModel
import torch
import torch.nn.functional as F

#Mean Pooling - Take attention mask into account for correct averaging
def mean_pooling(model_output, attention_mask):
    token_embeddings = model_output[0] #First element of model_output contains all token embeddings
    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
    return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)


# Sentences we want sentence embeddings for
# Example sentence
text = "Love is wanting to be loved"

# Load model from HuggingFace Hub
tokenizer = AutoTokenizer.from_pretrained('distilbert-base-uncased')
model = AutoModel.from_pretrained('distilbert-base-uncased')

# Tokenize sentences
encoded_input = tokenizer(text, padding=True, truncation=True, return_tensors='pt')

# Compute token embeddings
with torch.no_grad():
    model_output = model(**encoded_input)

# Perform pooling
sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask'])

# Normalize embeddings
sentence_embeddings = F.normalize(sentence_embeddings, p=2, dim=1)

print("Tensor Size", sentence_embeddings.size())
print("--------" * 10)
print("Sentence embeddings:")
print(sentence_embeddings)

# Tensor Size torch.Size([1, 768])
# --------------------------------------------------------------------------------
# Sentence embeddings:
# tensor([[ 7.1203e-02, -9.0556e-03,  2.0404e-02, -5.4984e-03,  5.3534e-02,
#          -2.7214e-02,  2.7177e-02,  5.1983e-02, -1.1366e-02, -4.1719e-02,
#              :             :           :           :             :
#           2.5733e-02, -2.1918e-02,  5.2480e-03, -5.7470e-04,  1.4644e-02,
#          -1.8896e-02, -4.5600e-03,  1.4625e-02]])

3-2. sentence-transformers 모델을 이용한 text embedding

: 'all-mpnet-base-v2' 모델을 HuggingFace에서 다운로드 하여 사용

sentence-transformers 모델에 대한 설명은 https://huggingface.co/sentence-transformers 를 참고하세요. 

# ! pip install -q -U sentence-transformers


# Text embedding by sentence-transformers model
# reference: https://huggingface.co/sentence-transformers/all-mpnet-base-v2
from sentence_transformers import SentenceTransformer

text = "Love is wanting to be loved"

model = SentenceTransformer('sentence-transformers/all-mpnet-base-v2')
text_embedding = model.encode(text)

print("Tensor Shape:", text_embedding.shape)
print("------" * 10)
print("Text Embedding:")
print(text_embedding)

# Tensor Shape: (768,)
# ------------------------------------------------------------
# Text Embedding:
# [ 7.25340098e-02 -3.43943425e-02  3.50002125e-02 -1.46801360e-02
#   1.79491900e-02  5.70273288e-02 -9.77409929e-02  2.65225749e-02
#      :               :               :               :
#   -6.68407883e-03  1.09006204e-02 -1.37606068e-02 -4.93713543e-02
#   3.27182375e-02  5.77081088e-03  4.32791896e-02 -1.55460704e-02]

이번 포스팅이 많은 도움이 되었기를 바랍니다. 

행복한 데이터 과학자 되세요!  :-)

이전 포스팅에서는 OpenAI API Key를 발급하는 방법(https://rfriend.tistory.com/794) 을 소개하였습니다. 

이번 포스팅에서는 애플리케이션을 개발할 때 REST API 로 OpenAI의 서비스를 사용할 수 있는 

(1) OpenAI API 를 이용해서 GPT-3 Text Embeddings 를 하는 방법

(2) OpenAI API 를 이용해서 ChatGPT 채팅을 하는 방법

을 소개하겠습니다. 

먼저, openai 모듈이 없으면 터미널에서 openai 파이썬 모듈을 설치해야 합니다 

-- terminal 에서 모듈 설치

pip install openai
pip install --force-reinstall charset-normalizer==3.1.0

그리고, Billing method 에서 API를 사용한 만큼의 비용을 결제할 때 사용하는 신용카드를 등록해야 합니다.  

(1) OpenAI API 를 이용해서 GPT-3 Text Embeddings 를 하는 방법

텍스트 임베팅 (Text Embeddings)은 텍스트 유사성(text similarity), 텍스트 군집화(clustering), 토픽 모델링(topic modeling), 텍스트 검색(text search), 코드 검색(code search) 등에 사용됩니다. 

openai.Embedding.create() 함수에 텍스트 문장을 input 으로 넣어주면, 1,536 차원의 리스트(list) 데이터 유형의 embeddings 를 output 으로 반환합니다. 

OpenAI API Key는 외부로 노출되지 않도록 보안에 유의하시기 바랍니다. (사용한 만큼 과금이 됩니다!)

## OpenAI API key
## how to get key: https://rfriend.tistory.com/794
openai_key = "Your_OpenAI_API_Key_here"


## Getting Embeddings
def get_embedding(content, openai_key):
    import openai
    
    openai.api_key = openai_key
    
    text = content 
    
    response = openai.Embedding.create(
        model="text-embedding-ada-002", 
        input = text.replace("\n", " ")
        )
    
    embedding = response['data'][0]['embedding']
    
    return embedding


## run the UDF above
content = """What is love?"""

text_embs = get_embedding(content, openai_key)


## sentence embeddings in detail
type(text_embs)
# list

len(text_embs)
# 1536

print(text_embs)
# [0.010716659016907215, -0.019867753610014915, 
#. -0.010219654999673367, -0.008119810372591019, 
#  ...... 
#  0.014152202755212784, -0.022837355732917786, 
#. -0.0026341236662119627, -0.03941245377063751]

(2) OpenAI API 를 이용해서 ChatGPT 채팅을 하는 방법

messages 에 {"role": "system", "content": "You are an intelligent assistant."} 를 설정해주고, input("User : ") 를 통해 사용자의 질문을 input으로 입력받아 {"role": "user", "content": message} 를 함께 묶어서 (append) OpenAI API 를 통해 ChatGPT 모델에 전달합니다.

그러면 OpenAI의 서버에서 openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=messages) 함수가 GPU를 사용해서 열심히 Text Generation Inference 를 해서 답변(reply)를 API를 통해 사용자에게 반환합니다. 

제일 마지막에 있는 messages.append({"role": "assistant", "content": reply}) 는 ChatGPT 가 답변한 내용(reply)를 messages 에 합쳐 놓아서 이후의 이어지는 질문에 이전 답변을 참고하는데 사용됩니다. (ChatGPT는 이전 상태에 대한 기억이 없기 때문에 이렇게 해주는 것임). 

#%% AI-assisted Chatting
import openai 

opneai_key = "Your_OpenAI_API_Key_here"
openai.api_key = opneai_key


messages = [ {"role": "system", 
              "content": "You are an intelligent assistant."} ]

message = input("User : ")
if message:
    messages.append(
        {"role": "user", 
         "content": message},
    )
    chat = openai.ChatCompletion.create(
        model="gpt-3.5-turbo", 
        messages=messages
    )

    
reply = chat.choices[0].message.content

print(f"ChatGPT: {reply}")

messages.append({"role": "assistant", "content": reply})


## 챗팅 결과
# User :  What is love?

# ChatGPT: Love is a complex emotion and can mean different things to different people. 
# Generally, love refers to a deep affection, care, and attachment felt towards someone or something. 
# It involves feelings of intense happiness, contentment, and a sense of connection. 
# Love can exist in various forms, such as romantic love, familial love, platonic love, 
# or even love for hobbies and interests. It is often characterized by selflessness, 
# understanding, support, and the desire to nurture and protect the well-being of the loved one. 
# Love can bring joy, fulfillment, and a sense of purpose to our lives, but it can also be challenging 
# and require effort, compromise, and understanding. Ultimately, 
# love is a fundamental aspect of human experience that enriches relationships 
# and contributes to personal growth and happiness.

이번 포스팅이 많은 도움이 되었기를 바랍니다. 

행복한 데이터 과학자 되세요!  :-)