1. 임베딩(Embedding)
1.1. 임베딩이란?
임베딩(Embedding) 이란 주로 자연어 처리(Natural Language Processing, NLP)에서 사용되는 용어로, 텍스트 데이터 내의 단어나 구 (phrase), 문장 등을 고정된 크기의 실수 벡터로 변환하는 과정을 의미합니다. 이러한 임베딩을 통해 컴퓨터는 텍스트를 수치적으로 분석하고 처리할 수 있게 됩니다. 임베딩은 단어나 문장의 의미를 벡터 공간에 매핑 (mapping)하여, 텍스트의 의미적, 문법적 속성을 반영하는 벡터로 변환 하는 것을 목표로 합니다.
1.2. 임베딩 과정
1) 토큰화(Tokenization)
우선, 원본 텍스트 데이터는 토큰화 과정을 거쳐 개별 단어나 서브워드(subword) 단위로 나누어집니다. 이 때 각 토큰은 텍스트의 기본 단위가 됩니다.
2) 인덱싱(Indexing)
토큰화된 각 토큰은 어휘 사전(Vocabulary)에 따라 고유한 인덱스로 변환됩니다. 어휘 사전은 모델이 인식할 수 있는 모든 토큰을 포함하며, 각 토큰은 사전에서의 위치에 따라 고유한 정수 인덱스를 가집니다.
3) 임베딩 조회(Embedding Lookup)
토큰의 인덱스를 사용하여 임베딩 행렬에서 해당 토큰의 벡터를 조회합 니다. 임베딩 행렬은 일반적으로 [|V|X D] 형태를 가집니다. 여기서 [|V|]는 어휘 사전의 크기, D는 임베딩 벡터의 차원입니다.
예를 들어, 토큰 "cat"이 어휘 사전에서 인덱스 5를 가지고, 임베딩 차원이 300이라면, "cat"에 대응하는 임베딩 벡터는 임베딩 행렬의 5번째 행에 해당합니다.
1.3. 임베딩의 중요성
차원축소: 자연어의 단어는 보통 수만에서 수십만 개에 이르는 큰 어휘 사전을 가지고 있습니다. 원핫 인코딩 같은 기초적인 방법을 사용하면 매우 높은 차원의 벡터가 필요하지만, 임베딩을 사용하면 훨씬 낮은 차 원(예: 50, 100, 300 차원)으로 정보를 표현할 수 있습니다.
의미적 유사성: 임베딩 과정에서 비슷한 의미를 가진 단어들은 벡터 공간에서도 서로 가까이 위치하게 됩니다. 이는 단어 간의 유사성뿐만 아니라, 다양한 NLP 작업에서 문맥적 의미를 이해하는 데 도움을 줍니다.
효율적인 연산: 낮은 차원의 벡터로 표현된 단어들은 컴퓨터가 더 빠르 고 효율적으로 처리할 수 있습니다. 이는 모델 학습 시간과 자원 사용을 줄여줍니다.
2. 임베딩(Embedding) 층 만들기
2.1. 임베딩층이란?
임베딩층은 딥러닝 아키텍처에서 특정 도메인의 데이터를 저차원의 연속 벡터 공간으로 매핑하는 역할을 수행합니다. 이 층은 주로 자연어 처리 (NLP)에서 사용되며, 각 단어나 토큰을 고정된 크기의 밀집 벡터로 변환 하여, 단어 간의 의미적 유사성을 벡터 공간에서의 거리로 나타내는 기능을 합니다. 딥러닝 모델 내에서 임베딩층은 초기 입력 데이터의 차원을 축소시키고, 연산을 효율적으로 만들어 주는 중요한 구성 요소입니다.
2.2. 임베딩 층 코드 예시
PyTorch에서는 toroh.nn. Enbedding 클래스를 사용하여 임베딩 층을 손쉽게 구성할 수 있습니다. 이 클래스는 주로 모델의 첫 번째 층으로 사용되며, 각 정수 인덱스를 해당 인덱스의 임베딩 벡터로 매핑합니다.
파라미터 설명은 아래와 같습니다.
num_embeddings: 단어사전의 단어의 총 개수
embedding_dim: 임베딩 과정에서 각 단어 또는 토큰이 표현되는 벡터의 크기입니다.
import torch
import torch.nn as nn
# 임베딩 층을 생성
embedding_layer = nn.Embedding(num_embeddings=10, embedding_dim=3)
print(embedding_layer)Embedding(10, 3)# 임의의 정수 인덱스로 구성된 입력 데이터 (예: 단어 인덱스)
input_data = torch.LongTensor([0, 1,])
# 입력 데이터를 임베딩 층에 전달하여 임베딩 벡터를 얻습니다.
embedded_data = embedding_layer(input_data)
print(embedded_data)tensor([[-1.5153, -0.2405, 1.6554],
[ 0.3699, -0.4339, 1.5226]], grad_fn=<EmbeddingBackward0>)3. Word2Vec
3.1. Word2Vec 이란?
Word2Vec 단어 임베딩을 위한 모델로, 2013년에 구글에서 개발되었습니다.
Word2Vec 단어를 벡터 공간에 매핑하여 단어 간의 의미적 관계를 수치적으로 표현하는 모델입니다. Word2Vec의 주요 목적은 대규모 텍스트 코퍼스 안에서 단어의 의미를 포착하여 저차원의 연속적인 벡터로 변환하는 것입니다. 이렇게 변환된 벡터는 단어의 의미적 유사성을 반영하며, 이를 임베딩 벡터 또는 단어 임베딩이라고 합니다.
3.2. Word2Vec 이론
Word2Vec에는 주로 두 가지 학습 알고리즘이 사용됩니다.
CBOW (Continuous Bag of Words): CBOW는 주변 단어들을 사용하여 중간에 위치한 타겟 단어를 예측합니다. 예를 들어, 문장 "the cat sits on the"에서 주변 단어들을 통해 'mat을 예측하는 방식입니다. 이 방법은 맥락 내의 여러 단어로부터 타겟 단어를 예측하기 때문에 작은 데이터셋에서 잘 작동합니다.
Skip-Gram: Skip-Gram은 타겟 단어로부터 주변의 맥락 단어들을 예측합니다. 예를 들어, "cat"이 주어졌을 때 "the", "sits", "on", "the" 등을 예측합니다. Skip-Gram은 각 타겟 단어로부터 주변 단어들을 독립적으로 예측하기 때문에, CBOW 보다 큰 데이터셋에서 더 좋은 성능을 보입니다.
3.3. Word2Vec 학습 코드 예시
Word2Vec을 사용하기 위해서 'gensim' 라이브러리를 사용할 수 있습니다.
sg 파라미터: 사용할 모델을 지정합니다 (sg=0은 CBOW, sg=1은 Skip-Gram)
window 파라미터: 타겟 단어를 중심으로 좌우에 몇 개의 단어까지 고려
min_count 파라미터: 단어의 최소 빈도수를 지정
workers 파라미터: 학습시 사용할 CPU 코어 수
import torch
import torch.nn as nn
from gensim.models import Word2Vec
# 샘플 문장
sentences = [
['this', 'is', 'the', 'first', 'sentence', 'for', 'word2vec'],
['this', 'is', 'the', 'second', 'sentence'],
['yet', 'another', 'sentence'],
['one', 'more', 'sentence'],
['and', 'the', 'final', 'sentence'],
]
# Word2Vec 모델 학습
model_wv = Word2Vec(sentences, vector_size=5, window=5, min_count=1, workers=4)
# 임베딩 매트릭스 크기 설정
num_embeddings = len(model_wv.wv.index_to_key)
embedding_dim = model_wv.vector_size
# 임베딩 매트릭스 만들기
wv_matrix = torch.FloatTensor([model_wv.wv[word] for word in model_wv.wv.index_to_key])
# 단어와 인덱스 매핑 확인
word_index_mapping = model_wv.wv.key_to_index
print('----단어사전----')
for word, index in word_index_mapping.items():
print(f"{index}: {word}")
print('----임베딩 메트릭스----\n', wv_matrix)
print('임베딩 메트릭스 크기:', wv_matrix.shape)
# PyTorch 임베딩 레이어에 사전 훈련된 가중치를 사용
w2v_embedding_layer = nn.Embedding.from_pretrained(wv_matrix, freeze=False)
print(w2v_embedding_layer)
input_data = torch.LongTensor([0, 1]) # [sentence, the]
# 입력 데이터를 임베딩 층에 전달하여 임베딩 벡터를 얻습니다.
embedded_data = w2v_embedding_layer(input_data)
print(embedded_data)----단어사전----
0: sentence
1: the
2: is
3: this
4: final
5: and
6: more
7: one
8: another
9: yet
10: second
11: word2vec
12: for
13: first
----임베딩 메트릭스----
tensor([[-0.0107, 0.0047, 0.1021, 0.1802, -0.1861],
[-0.1423, 0.1292, 0.1795, -0.1003, -0.0753],
[ 0.1476, -0.0307, -0.0907, 0.1311, -0.0972],
[-0.0363, 0.0575, 0.0198, -0.1657, -0.1890],
[ 0.1462, 0.1014, 0.1352, 0.0153, 0.1270],
[-0.0681, -0.0189, 0.1154, -0.1504, -0.0787],
[-0.1502, -0.0186, 0.1908, -0.1464, -0.0467],
[-0.0388, 0.1615, -0.1186, 0.0009, -0.0951],
[-0.1921, 0.1001, -0.1752, -0.0878, -0.0007],
[-0.0059, -0.1532, 0.1923, 0.0996, 0.1847],
[-0.1632, 0.0899, -0.0827, 0.0165, 0.1700],
[-0.0892, 0.0904, -0.1357, -0.0710, 0.1880],
[-0.0316, 0.0064, -0.0828, -0.1537, -0.0302],
[ 0.0494, -0.0178, 0.1107, -0.0549, 0.0452]])
임베딩 메트릭스 크기: torch.Size([14, 5])
Embedding(14, 5)
tensor([[-0.0107, 0.0047, 0.1021, 0.1802, -0.1861],
[-0.1423, 0.1292, 0.1795, -0.1003, -0.0753]],
grad_fn=<EmbeddingBackward0>)
3.4 사전학습 모델 코드 예시
import torch
import torch.nn as nn
import gensim.downloader as api
# word2vec-ruscorpora-300 모델 로드
wv_vectors = api.load('word2vec-ruscorpora-300')
# 어휘 크기와 임베딩 차원을 가져옵니다.
vocab_size = len(wv_vectors.key_to_index)
embedding_dim = wv_vectors.vector_size
# 임베딩 행렬을 준비합니다.
weights = torch.FloatTensor(wv_vectors.vectors)
wv_embedding_layer = nn.Embedding.from_pretrained(weights, freeze=False)
print(wv_embedding_layer)# 임의의 정수 인덱스로 구성된 입력 데이터 (예: 단어 인덱스)
input_data = torch.LongTensor([0, 1])
# 입력 데이터를 임베딩 층에 전달하여 임베딩 벡터를 얻습니다.
embedded_data = wv_embedding_layer(input_data)
print(embedded_data)tensor([[-0.0192, -0.0443, 0.0114, 0.1661, -0.0472, -0.0196, -0.0083, 0.0136,
-0.0684, 0.0513, 0.0114, 0.0386, -0.0284, 0.0114, -0.0111, -0.0080,
0.0277, 0.0066, -0.0332, -0.0141, 0.0754, 0.0658, -0.0895, 0.0482,
-0.0290, -0.0866, 0.0163, 0.0382, 0.0271, 0.0176, 0.0340, -0.0510,
0.0663, -0.0745, -0.0551, 0.0317, 0.0791, -0.0235, 0.0255, 0.0115,
-0.0044, 0.0191, 0.0543, -0.0925, 0.0692, -0.1207, 0.0221, -0.0576,
0.0216, -0.1466, 0.0589, 0.0186, 0.0293, -0.0094, 0.1003, -0.0417,
-0.1334, 0.0646, 0.0214, -0.0021, -0.0357, 0.0387, -0.0715, -0.0108,
0.0396, 0.0073, -0.0769, 0.0347, -0.0592, 0.0878, -0.0556, 0.0112,
-0.0526, -0.0820, -0.0115, -0.0097, 0.0682, -0.0351, 0.0304, 0.0024,
-0.0008, -0.0474, -0.0720, -0.0846, 0.0519, 0.0203, 0.0096, 0.0250,
-0.0680, -0.0594, 0.0552, 0.0155, -0.0710, -0.0464, -0.0277, -0.0523,
0.0651, -0.0205, 0.0221, -0.0392, -0.0314, -0.0416, 0.0737, -0.0053,
-0.0363, -0.0260, 0.0262, -0.0302, -0.0539, 0.0153, 0.0648, 0.0776,
-0.0956, -0.0362, -0.0288, -0.0092, -0.0203, -0.0255, -0.0516, 0.0366,
0.0002, -0.0336, -0.0683, -0.0393, 0.0191, -0.0726, -0.0192, 0.0025,
0.0004, 0.1212, -0.0754, -0.0233, -0.0293, 0.0641, -0.0813, -0.0790,
-0.1056, -0.0270, -0.0147, -0.0037, 0.0031, 0.0639, 0.0294, 0.0150,
0.0206, 0.0819, -0.0126, 0.0872, 0.0579, 0.0755, -0.0930, 0.0043,
-0.1074, 0.0599, -0.0658, -0.0046, 0.0683, 0.0208, -0.0611, 0.0072,
-0.0310, -0.0210, -0.1189, 0.0228, 0.0248, -0.0450, 0.0504, -0.0062,
-0.0672, -0.0268, 0.0532, 0.0609, -0.0514, 0.0888, 0.1172, -0.0618,
0.1487, 0.0242, 0.0391, 0.0113, -0.0517, -0.0085, 0.0487, -0.0022,
0.0067, -0.0267, 0.0442, 0.0684, -0.0369, -0.0257, 0.0546, 0.0817,
-0.0885, -0.0248, -0.0383, -0.0006, 0.0016, 0.0061, -0.0300, -0.0529,
-0.0078, -0.0564, 0.0208, -0.0610, -0.0290, 0.0220, -0.1178, 0.0602,
-0.0314, 0.1026, 0.0315, 0.0430, 0.0173, 0.0821, 0.0814, 0.0431,
-0.0864, 0.0638, 0.0328, 0.0547, -0.0546, -0.0134, 0.0542, 0.0481,
0.0428, -0.0547, -0.0080, 0.0631, -0.0169, -0.0062, 0.0306, 0.0394,
-0.0692, 0.1187, -0.1076, -0.0320, -0.0620, 0.0038, 0.0087, -0.0426,
0.1161, 0.0781, 0.0464, 0.1198, -0.0376, 0.0288, 0.1479, -0.0466,
-0.0641, 0.0032, 0.0042, -0.0919, 0.0387, 0.0847, 0.0790, -0.0940,
0.1983, 0.0348, 0.0581, 0.0745, 0.0016, -0.0525, -0.0527, -0.0509,
0.0535, 0.0896, 0.0598, 0.0236, 0.0118, -0.0243, 0.0435, 0.1114,
0.0232, 0.0506, -0.0019, -0.0436, -0.0446, 0.0205, 0.0253, 0.0143,
-0.0665, 0.0434, 0.0920, 0.0173, -0.0252, 0.0178, -0.1542, -0.0443,
-0.0391, 0.1181, 0.0499, -0.0488, -0.0160, 0.0779, 0.0003, -0.0451,
-0.0237, -0.0682, -0.1113, -0.0187],
[-0.1395, 0.0095, 0.0967, -0.0521, -0.0313, 0.0506, -0.0253, 0.0103,
0.0671, -0.0050, 0.0518, -0.0707, -0.0939, 0.0394, -0.0019, 0.0062,
0.0344, -0.0068, 0.0904, -0.0853, 0.0068, 0.0793, -0.0468, 0.1664,
0.0513, -0.1283, 0.0483, -0.0124, 0.0615, 0.0594, 0.0359, 0.0460,
0.0997, -0.0271, -0.0845, 0.0158, 0.0607, 0.0908, -0.0232, 0.0106,
-0.0246, 0.0151, -0.0240, 0.0047, -0.0192, 0.0708, 0.0648, 0.0057,
0.0842, -0.0820, 0.0509, 0.0765, 0.0326, 0.0505, 0.0835, -0.0191,
-0.1471, 0.0250, 0.0056, -0.0369, -0.0641, -0.0009, 0.0776, -0.0105,
0.0196, 0.0243, -0.0585, 0.0021, 0.0339, 0.0781, 0.0102, 0.0205,
0.0424, -0.0991, -0.0065, 0.0136, -0.0044, 0.0196, 0.0543, -0.0331,
-0.0405, 0.0804, -0.0199, -0.0728, 0.0154, -0.0280, -0.0966, 0.0384,
-0.0836, -0.0484, -0.0533, -0.0791, 0.0393, 0.0651, 0.0072, 0.0472,
-0.0190, -0.0529, 0.0111, -0.0160, -0.0647, -0.0414, -0.0149, -0.0375,
0.0033, -0.0353, 0.0229, -0.0732, 0.0238, -0.0153, -0.0047, -0.0237,
0.0194, 0.0442, -0.0310, 0.0127, 0.0948, 0.0274, 0.0183, -0.0036,
0.0515, -0.0627, -0.0163, 0.0107, -0.0517, 0.0174, -0.0403, 0.0485,
-0.0987, 0.0466, -0.0746, -0.0269, -0.0014, 0.1505, 0.0028, -0.0266,
-0.0610, 0.0627, 0.0448, -0.0052, 0.0294, -0.0387, -0.0595, -0.0679,
0.0351, -0.0180, -0.0130, -0.0531, -0.0023, 0.0296, -0.0140, 0.1004,
-0.0559, 0.0514, -0.0738, 0.0568, 0.0010, 0.0656, -0.0235, 0.0193,
-0.0701, 0.0319, -0.0538, 0.0353, -0.0081, -0.1350, -0.0150, 0.0140,
-0.1972, -0.0292, 0.1325, -0.0482, 0.0389, 0.0341, 0.0515, 0.0766,
-0.0112, 0.0529, 0.0480, -0.0869, -0.0096, 0.0800, 0.0024, 0.0118,
0.0095, -0.0535, 0.0569, -0.0337, 0.0468, -0.0711, -0.0354, -0.1135,
0.0481, 0.0565, 0.0856, -0.0025, 0.0375, 0.0064, 0.0157, -0.0304,
0.0102, -0.0176, -0.0871, -0.0245, -0.0681, -0.0295, -0.0443, -0.0150,
0.0253, 0.0062, -0.0386, 0.0186, -0.0196, 0.0259, 0.0781, -0.0242,
0.0323, 0.0572, -0.0710, 0.1176, -0.0024, -0.0401, -0.0397, 0.0658,
0.0285, 0.0062, -0.0911, 0.0476, -0.0160, -0.0027, -0.0212, -0.0858,
-0.0166, 0.0846, -0.1697, -0.0654, 0.0335, 0.0536, -0.0739, -0.0352,
0.0618, 0.0360, -0.0096, 0.0289, 0.0050, 0.0850, 0.1203, -0.0918,
-0.0650, 0.0234, -0.0272, -0.1628, 0.0908, 0.1382, 0.0822, -0.0397,
0.0256, 0.0115, 0.0518, 0.0628, -0.0281, 0.0153, -0.0371, -0.0446,
-0.0281, -0.0111, -0.0250, -0.0095, -0.0480, -0.0449, -0.0243, -0.0269,
-0.0043, 0.0310, 0.0186, -0.0636, 0.0965, -0.0005, -0.0291, -0.0090,
-0.1092, 0.0390, 0.1126, -0.0161, 0.0349, -0.0339, -0.1450, -0.0846,
-0.0127, 0.0487, -0.0142, -0.0475, -0.0559, 0.0378, -0.0359, -0.0346,
0.0244, 0.1361, -0.0111, 0.0706]], grad_fn=<EmbeddingBackward0>)
4. GloVe
4.1. GloVe 이란?
GloVe(Global Vectors for Word Representation)는 단어 임베딩을 위한 모델로, 2014년에 스탠퍼드 대학교의 연구팀에 의해 개발되었습니다.
Glove는 전통적인 단어 임베딩 방법과 달리, 단어의 동시 등장 확률에 기반하여 작동합니다. 즉, 단어 쌍의 통계 정보를 기반으로 단어 벡터를 학습합니다. 이는 말뭉치에서 함께 등장하는 두 단어 사이의 관계를 파악하는 것으로, 단어 간의 의미적 관 계를 잡아내기 위한 중요한 정보를 제공합니다.
GloVe의 특징은 아래와 같습니다.
비슷한 문맥의 단어 임베딩: GloVe는 비슷한 문맥에서 사용되는 단어들이 벡터 공간에서 가까운 위치에 임베딩되도록 합
니다.
4.2. Glove 이론
4.3. 사전 학습된 GloVe 모델
# glove-wiki-gigaword-50 모델 로드
glove_vectors = api.load('glove-wiki-gigaword-50')
# 어휘 크기와 임베딩 차원을 가져옵니다.
vocab_size = len(glove_vectors.key_to_index)
embedding_dim = glove_vectors.vector_size
# 임베딩 행렬을 준비합니다.
weights = torch.FloatTensor(glove_vectors.vectors)
glove_embedding_layer = nn.Embedding.from_pretrained(weights, freeze=False)
print(glove_embedding_layer)# 임의의 정수 인덱스로 구성된 입력 데이터 (예: 단어 인덱스)
input_data = torch.LongTensor([0, 1])
# 입력 데이터를 임베딩 층에 전달하여 임베딩 벡터를 얻습니다.
embedded_data = glove_embedding_layer(input_data)
print(embedded_data)tensor([[ 4.1800e-01, 2.4968e-01, -4.1242e-01, 1.2170e-01, 3.4527e-01,
-4.4457e-02, -4.9688e-01, -1.7862e-01, -6.6023e-04, -6.5660e-01,
2.7843e-01, -1.4767e-01, -5.5677e-01, 1.4658e-01, -9.5095e-03,
1.1658e-02, 1.0204e-01, -1.2792e-01, -8.4430e-01, -1.2181e-01,
-1.6801e-02, -3.3279e-01, -1.5520e-01, -2.3131e-01, -1.9181e-01,
-1.8823e+00, -7.6746e-01, 9.9051e-02, -4.2125e-01, -1.9526e-01,
4.0071e+00, -1.8594e-01, -5.2287e-01, -3.1681e-01, 5.9213e-04,
7.4449e-03, 1.7778e-01, -1.5897e-01, 1.2041e-02, -5.4223e-02,
-2.9871e-01, -1.5749e-01, -3.4758e-01, -4.5637e-02, -4.4251e-01,
1.8785e-01, 2.7849e-03, -1.8411e-01, -1.1514e-01, -7.8581e-01],
[ 1.3441e-02, 2.3682e-01, -1.6899e-01, 4.0951e-01, 6.3812e-01,
4.7709e-01, -4.2852e-01, -5.5641e-01, -3.6400e-01, -2.3938e-01,
1.3001e-01, -6.3734e-02, -3.9575e-01, -4.8162e-01, 2.3291e-01,
9.0201e-02, -1.3324e-01, 7.8639e-02, -4.1634e-01, -1.5428e-01,
1.0068e-01, 4.8891e-01, 3.1226e-01, -1.2520e-01, -3.7512e-02,
-1.5179e+00, 1.2612e-01, -2.4420e-02, -4.2961e-02, -2.8351e-01,
3.5416e+00, -1.1956e-01, -1.4533e-02, -1.4990e-01, 2.1864e-01,
-3.3412e-01, -1.3872e-01, 3.1806e-01, 7.0358e-01, 4.4858e-01,
-8.0262e-02, 6.3003e-01, 3.2111e-01, -4.6765e-01, 2.2786e-01,
3.6034e-01, -3.7818e-01, -5.6657e-01, 4.4691e-02, 3.0392e-01]],
grad_fn=<EmbeddingBackward0>)5. FastText
5.1. FastText 란?
Word2Vec GloVe는 단어 단위로 벡터를 학습합니다. 이는 희귀 단어에 대한 임베딩이 부정확할 수 있다는 단점이 있습니다.
FastText는 2017년 Facebook의 AI 연구팀에서 개발한 단어 임베딩(Word Embedding) 및 텍스트 분류 도구입니다.
FastText는 단어를n-그램(n-gram)으로 분할하여 학습하므로 희귀 단어와 새로운 단어에 대해서도 의미를 추론할 수 있습 니다.
예를 들어, "where"라는 단어를 3-그램으로 분할하면 다음과 같이 나눌 수 있습니다.
"whe", "her", "ere"
FastText의 특징은 아래와 같습니다.
어절 기반의 임베딩: 단어를 구성하는 n-그램(문자 단위)으로 분할하여 학습합니다.
텍스트 분류 가능: 단어 임베딩뿐만 아니라 텍스트 분류 작업에도 매우 효과적입니다. 문서 전체를 벡터로 변환한 후, 이 벡 터를 사용하여 분류 작업을 수행할 수 있습니다.
5.2. FastText 이론
Word2Vec과 마찬가지로 FastText도 Skip-gram과 CBOW 모델을 이용해 학습합니다.
CBOW (Continuous Bag of Words): CBOW는 주변 단어들을 사용하여 중간에 위치한 타겟 단어를 예측합니다. 예를 들어, 문장 "the cat sits on the'에서 주변 단어들을 통해 'mat"을 예측하는 방식입니다. 이 방법은 맥락 내의 여러 단어로부터 타겟 단어를 예측하기 때문에 작은 데이터셋에서 잘 작동합니다.
Skip-Gram: Skip-Gram은 타겟 단어로부터 주변의 맥락 단어들을 예측합니다. 예를 들어, "cat'이 주어졌을 때 "the", "sits", "on", "the' 등을 예측합니다. Skip-Gram은 각 타겟 단어로부터 주변 단어들을 독립적으로 예측하기 때문에, CBOW보다 큰 데이터셋에서 더 좋은 성능을 보입니다.
5.3. Word2Vec과의 차이점
FastText는 문자 n-그램을 사용하여 단어의 내부 구조를 반영하고, 특히 희귀 단어와 형태소 변형이 많은 언어에 대해 더 나은 성능을 제공합니다.
Word2Vec는 단어 자체를 학습 단위로 사용하여 빠르고 효율적 인 단어 임베딩을 생성하지만, 희귀 단어와 새로운 단어에 대한 대응이 부족합니다.
import gensim.downloader as api
import torch
import torch.nn as nn
# FastText 모델 로드
model_name = 'fasttext-wiki-news-subwords-300'
word_vectors = api.load(model_name)
# 어휘 크기와 임베딩 차원 가져오기
vocab_size = len(word_vectors.key_to_index)
embedding_dim = word_vectors.vector_size
# 임베딩 행렬 준비
weights = torch.FloatTensor(word_vectors.vectors)
# PyTorch 임베딩 레이어에 FastText 임베딩 반영
embedding_layer = nn.Embedding.from_pretrained(weights, freeze=False)
print(embedding_layer)
# 임의의 정수 인덱스로 구성된 입력 데이터 (예: 단어 인덱스)
input_data = torch.LongTensor([0, 1])
# 입력 데이터를 임베딩 층에 전달하여 임베딩 벡터를 얻습니다.
embedded_data = embedding_layer(input_data)
print(embedded_data)
실행결과
tensor([[-0.0107, 0.0047, 0.1021, 0.1802, -0.1861],
[-0.1423, 0.1292, 0.1795, -0.1003, -0.0753]],
grad_fn=<EmbeddingBackward0>)
'딥러닝 > 딥러닝: 자연어 처리' 카테고리의 다른 글
| Seq2Seq 개념 (1) | 2025.02.28 |
|---|---|
| 자연어 처리 모델 (0) | 2025.02.26 |
| AlexNet (2012) (0) | 2025.02.25 |
| LeNet-5 (1998) (0) | 2025.02.24 |
| 토크나이저 (0) | 2025.02.19 |