1
2
    (1) 각 단어에 고유한 정수 인덱스 부여.
    (2) 각 인덱스의 위치에 단어 토큰의 등장 횟수를 기록한 벡터 생성. 

1
2
3
4
5
6
    문서1: "I love machine learning."
    문서2: "Machine learning is fun."
    
    BoW 벡터:
    문서1: [1, 1, 1, 1, 0, 0]  # "I", "love", "machine", "learning", "is", "fun"의 순서
    문서2: [0, 0, 1, 1, 1, 1]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from konlpy.tag import Okt

okt = Okt()

def build_bag_of_words(document):
  # 온점 제거 및 형태소 분석
  document = document.replace('.', '')
  tokenized_document = okt.morphs(document)

  word_to_index = {}
  bow = []

  for word in tokenized_document:  
    if word not in word_to_index.keys():
      word_to_index[word] = len(word_to_index)  
      # BoW에 전부 기본값 1을 넣는다.
      bow.insert(len(word_to_index) - 1, 1)
    else:
      # 재등장하는 단어의 인덱스
      index = word_to_index.get(word)
      # 재등장한 단어는 해당하는 인덱스의 위치에 1을 더한다.
      bow[index] = bow[index] + 1

  return word_to_index, bow

1
2
3
4
5
6
7
8
9
10
    from sklearn.feature_extraction.text import TfidfVectorizer
    
    documents = ["I love machine learning.", "Machine learning is fun."]
    
    tfidf_vectorizer = TfidfVectorizer()
    tfidf_matrix = tfidf_vectorizer.fit_transform(documents)
    
    print(tfidf_matrix.toarray())
    print(tfidf_vectorizer.get_feature_names_out())
    

1
2
3
    (1) 텍스트를 N개의 단어 묶음으로 나눕니다.
    (2) 각 N-Gram 묶음을 벡터화합니다.
    

1
2
3
4
5
6
    문장: "I love machine learning"
    
    Unigram: ["I", "love", "machine", "learning"]
    Bigram: ["I love", "love machine", "machine learning"]
    Trigram: ["I love machine", "love machine learning"]
    4-gram: ["I love machine learning"]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    from sklearn.feature_extraction.text import CountVectorizer
    
    bigram_vectorizer = CountVectorizer(ngram_range=(2, 2))
    trigram_vectorizer = CountVectorizer(ngram_range=(3, 3))
    
    documents = ["I love machine learning."]
    
    bigram_matrix = bigram_vectorizer.fit_transform(documents)
    trigram_matrix = trigram_vectorizer.fit_transform(documents)
    
    print("Bigram:\\n", bigram_matrix.toarray())
    print("Bigram Features:\\n", bigram_vectorizer.get_feature_names_out())
    
    print("Trigram:\\n", trigram_matrix.toarray())
    print("Trigram Features:\\n", trigram_vectorizer.get_feature_names_out())
    

1
2
3
4
    (1) 단어 시퀀스를 입력받아 단어 임베딩 레이어를 통해 고정 길이의 벡터로 변환합니다.
    (2) 은닉층을 거쳐 다음 단어의 확률 분포를 출력합니다.
    (3) 모델을 학습하여 단어 임베딩 벡터를 최적화합니다.
    

1
2
3
    문장: "I love machine learning"
    >>> 입력: ["I", "love", "machine"]
    >>> 출력: "learning"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
    from tensorflow.keras.preprocessing.text import Tokenizer
    from tensorflow.keras.preprocessing.sequence import pad_sequences
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Embedding, LSTM, Dense
    
    # 샘플 데이터
    sentences = ["I love machine learning", "Machine learning is fun", "I love deep learning"]
    
    # 토크나이저 생성
    tokenizer = Tokenizer()
    tokenizer.fit_on_texts(sentences)
    total_words = len(tokenizer.word_index) + 1
    
    # 시퀀스 생성
    input_sequences = []
    for line in sentences:
        token_list = tokenizer.texts_to_sequences([line])[0]
        for i in range(1, len(token_list)):
            n_gram_sequence = token_list[:i+1]
            input_sequences.append(n_gram_sequence)
    
    # 패딩
    max_sequence_len = max([len(x) for x in input_sequences])
    input_sequences = pad_sequences(input_sequences, maxlen=max_sequence_len, padding='pre')
    
    # 특징과 레이블 분리
    X, y = input_sequences[:,:-1], input_sequences[:,-1]
    
    # 레이블 원-핫 인코딩
    y = tf.keras.utils.to_categorical(y, num_classes=total_words)
    
    # 모델 생성
    model = Sequential()
    model.add(Embedding(total_words, 10, input_length=max_sequence_len-1))
    model.add(LSTM(100))
    model.add(Dense(total_words, activation='softmax'))
    
    # 모델 컴파일
    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    
    # 모델 학습
    model.fit(X, y, epochs=100, verbose=1)
    
    # 예측
    seed_text = "I love"
    next_words = 3
    for _ in range(next_words):
        token_list = tokenizer.texts_to_sequences([seed_text])[0]
        token_list = pad_sequences([token_list], maxlen=max_sequence_len-1, padding='pre')
        predicted = model.predict(token_list, verbose=0)
        output_word = tokenizer.index_word[np.argmax(predicted)]
        seed_text += " " + output_word
    print(seed_text)
    

1
2
3
4
5
6
7
8
9
10
11
    문장: "The cat sat on the mat"
    중심 단어: "sat"
    주변 단어: ["The", "cat", ___, "on", "the", "mat"]
    
    ## CBOW: 주변 단어들 → 중심 단어 예측
    >> 인풋: ["The", "cat", "on", "the", "mat"]
    >> 아웃풋: "sat"
    
    ## Skip-gram: 중심 단어 → 주변 단어들 예측
    >> 인풋: "sat"
    >> 아웃풋: ["The", "cat", "on", "the", "mat"]

1
2
3
4
5
6
7
8
9
10
    from gensim.models import Word2Vec
    
    sentences = [["the", "cat", "sat", "on", "the", "mat"],
                 ["the", "dog", "sat", "on", "the", "couch"]]
    
    model = Word2Vec(sentences, vector_size=100, window=5, min_count=1, sg=0)  # CBOW
    
    vector = model.wv['cat']
    print(vector)
    

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
문장들:
1. "The cat sits on the mat"
2. "The dog chases the cat"
3. "A cat and a dog play"

>> 문맥 윈도우 크기: 2 (중심 단어의 양쪽으로 2개의 단어까지 고려)

>> 동시 등장 행렬:
       the  cat  sits  on   mat  dog  chases  a    and  play
the    0    3    1     1    1    1    1       0    0    0
cat    3    0    1     1    1    2    1       2    1    1
sits   1    1    0     1    1    0    0       0    0    0
on     1    1    1     0    1    0    0       0    0    0
mat    1    1    1     1    0    0    0       0    0    0
dog    1    2    0     0    0    0    1       2    1    1
chases 1    1    0     0    0    1    0       0    0    0
a      0    2    0     0    0    2    0       0    1    1
and    0    1    0     0    0    1    0       1    0    1
play   0    1    0     0    0    1    0       1    1    0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
from urllib.request import urlretrieve
import zipfile

# glove 사전학습 파일 다운로드
urlretrieve("http://nlp.stanford.edu/data/glove.6B.zip", filename="glove.6B.zip")

# glove 사전학습 파일 압축 해제
with zipfile.ZipFile('glove.6B.zip', 'r') as zip_ref:
    zip_ref.extractall()

from gensim.scripts.glove2word2vec import glove2word2vec
from gensim.models import KeyedVectors

# GloVe 파일 경로
glove_input_file = './glove.6B.100d.txt'

# 변환된 Word2Vec 파일 경로
word2vec_output_file = 'glove.6B.100d.word2vec.txt'

# GloVe 형식을 Word2Vec 형식으로 변환
glove2word2vec(glove_input_file, word2vec_output_file)

# 변환된 Word2Vec 형식의 파일을 로드
model = KeyedVectors.load_word2vec_format(word2vec_output_file, binary=False)

# 특정 단어의 벡터를 출력
vector = model['cat']
print(vector)
    

1
2
3
4
    ## Subword Model
    (1) 단어를 문자 n-gram으로 분해합니다.
    (2) 각 n-gram 벡터를 합산하여 단어 벡터를 생성합니다.
    

1
2
3
4
    단어: "apple"
    문자 n-gram: ["a", "ap", "app", "p", "pp", "ple", "e"]
    벡터 학습: 각 문자 n-gram의 벡터를 합산하여 단어 벡터를 생성합니다.
    

1
2
3
4
5
6
7
8
9
    from gensim.models import FastText
    
    sentences = [["the", "cat", "sat", "on", "the", "mat"],
                 ["machine", "learning", "is", "fun"]]
    
    model = FastText(sentences, vector_size=100, window=5, min_count=1)
    vector = model.wv['cat']
    print(vector)
    

1
2
3
    (1) 문서 내의 모든 단어를 임베딩 벡터로 변환합니다.
    (2) 변환된 모든 단어 임베딩 벡터의 평균을 구합니다.
    

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    import numpy as np
    from gensim.models import Word2Vec
    
    sentences = [["I", "love", "machine", "learning"], ["Machine", "learning", "is", "fun"]]
    word2vec_model = Word2Vec(sentences, vector_size=100, window=5, min_count=1, workers=4)
    
    def average_word_embeddings(document):
    
        vectors = [word2vec_model.wv[word] for word in document if word in word2vec_model.wv]
        
        return np.mean(vectors, axis=0)
    
    document = ["I", "love", "machine", "learning"]
    document_vector = average_word_embeddings(document)
    
    print(document_vector)
    

1
2
    (1) 각 문서에 고유한 ID를 부여합니다.
    (2) 문맥 단어와 문서 ID를 입력으로 받아 중심 단어를 예측합니다.

1
2
3
4
5
6
7
8
9
10
    from gensim.models.doc2vec import Doc2Vec, TaggedDocument
    
    documents = [TaggedDocument(words=["I", "love", "machine", "learning"], tags=['doc1']),
                 TaggedDocument(words=["Machine", "learning", "is", "fun"], tags=['doc2'])]
    
    model = Doc2Vec(documents, vector_size=100, window=2, min_count=1, workers=4, dm=1)  # PV-DM
    vector = model.dv['doc1']
    
    print(vector)
    

1
2
3
    (1) 각 문서에 고유한 ID를 부여합니다.
    (2) 문서 ID를 입력으로 받아 중심 단어를 예측합니다.
    

1
2
3
4
5
6
7
8
9
10
11
    from gensim.models.doc2vec import Doc2Vec, TaggedDocument
    
    documents = [TaggedDocument(words=["I", "love", "machine", "learning"], tags=['doc1']),
                 TaggedDocument(words=["Machine", "learning", "is", "fun"], tags=['doc2'])]
    
    model = Doc2Vec(documents, vector_size=100, window=2, min_count=1, workers=4, dm=0)  # PV-DBOW
    vector = model.dv['doc1']
    
    print(vector)