[NLP] Thesaurus(시소러스), Co-occurence Matrix(동시발생 행렬)

• 오랜만에 NLP 관련 글을 쓰네요.. 시간 나는대로 열심히 쓰고 올려 보도록 하겠습니다.

 

Thesaursus - 시소러스

시소러스(Thesaurus)는 단어와 그 의미를 연결시켜주는 도구입니다.
주로 특정 단어와 의미적으로 유사한 단어(동의어)와 반대 의미를 가진 단어(반의어)를 제공하여, 글을 쓰거나 말을 할 때 다양한 표현을 사용할 수 있도록 돕습니다.

• 다른 의미로 말하면, 유의어 사전으로 '뜻이 같은 단어(동의어)'나 '뜻이 비슷한 단어(유의어)'가 한 그룹으로 분류되어 있습니다.

동의어의 예시입니다. 'car', 'automobile'은 '자동차'를 뜻하는 동의어 입니다.

• 또한 NLP에서 이용되는 시소러스에서는 단어 사이의 '상위, 하위' 혹은 '전체, 부분'등 더 세세한 관계까지 정의해둔 경우가 있습니다.
• 예를 들어서 아래의 그래프 처럼 관계를 정의합니다.

단어들의 의미를 상, 하위 관계에 기초해 그래프로 표현

• 이처럼 모든 단어에 데한 유의어 집합을 만든다음, 단어들의 관계를 그래프로 표현하여, 단어 사이의 연결을 정의할 수 있습니다.

 

WordNet

NLP분야에서 가장 유명한 시소러스는 WordNet입니다.

• WordNet은 프린스턴 대학교에서 개발된 영어 어휘 데이터베이스입니다.
• 사람의 언어 이해를 돕기 위해 만들어졌으며, 단어 간의 의미 관계를 중심으로 구성되어 있습니다.
  
  • 어휘 관계망: WordNet은 단어를 동의어 집합(synset)으로 그룹화하여, 각 그룹이 특정 개념을 나타내도록 합니다. 이를 통해 같은 의미를 가지는 다양한 단어들을 쉽게 찾을 수 있습니다.
  • 의미 관계: 단어들 간의 다양한 의미 관계를 정의합니다. 예를 들어, 상위어/하위어(hypernym/hyponym), 반의어(antonym), 부분/전체 관계(meronym/holonym) 등을 포함합니다.
  • 동의어와 정의: 각 동의어 집합에는 그 의미를 설명하는 정의(gloss)가 포함되어 있어, 단어의 정확한 의미를 파악할 수 있습니다.
  • 다중 감각: 하나의 단어가 여러 가지 의미를 가질 수 있는 경우, WordNet은 각 의미를 별도로 정의하고 관련 단어를 연결하여 제공합니다.
• 그리고, WordNet을 사용하면 '유의어'를 얻거나 '단어 네트워크'를 이용하여 단어 사이의 유사도를 구할 수 있습니다.

 

Thesaursus(시소러스)의 문제점

WordNet과 같은 Thesaursus(시소러스)에는 수많은 단어에 데한 동의어, 계층 구조등의 관계가 정의되어 있습니다.

• 그리고 이 Thesaursus(시소러스)를 이용하면 '단어의 의미'를 (간접적으로라도) 컴퓨터에 전달할 수 있습니다.
• 하지만 이처럼 사람이 수작업으로 labeling하는 방식에는 크나큰 결점이 존재합니다.

 

시대 변화에 대응하기 어렵습니다.

• 우리가 사용하는 말은 때때로 새로운 단어가 생겨나고, 옛말은 언젠가 잊혀집니다. 또한 시대에 따라 언어의 의미가 변하기도 있습니다.
• 이런 단어의 변화에 대응하려면 Thesaursus(시소러스)를 사람이 수작업으로 끊임없이 갱신해야 합니다.

 

사람을 쓰는 비용은 크다

• Thesaursus(시소러스)를 만드는 데는 엄청난 인적 비용이 발생합니다.
• 영어를 예로 들면, 현존하는 영어 단어의 수는 1,000만 개가 넘는다고 합니다. 따라서 이상적으로는 이 방대한 단어들 모두에 대해 단어 사이의 관계를 정의해줘야 합니다.
• 참고로 WordNet에 등록된 단어는 20만 개 이상입니다.

 

단어의 미묘한 차이를 표현할 수 없다.

• Thesaursus(시소러스)는 뜻이 비슷한 단어들을 묶습니다.
• 그러나 실제로 비슷한 단어들이라도 미묘한 차이가 있습니다. 예컨대 ‘빈티지[vintage, 낡고 오래된 것]’와 ‘레트로[retro, 복고]’는 의미가 같지만, 용법은 다릅니다.
• Thesaursus(시소러스)에서는 이러한 미묘한 차이를 표현할 수 없습니다. 그렇다고 이를 수작업으로 표현하려면 매우 곤란합니다.

이처럼 시소러스를 사용하는 기법(단어의 의미를 사람이 정의하는 기법)에는 커다란 문제가 있습니다.
이 문제를 피하기 위해, 사용하는 ‘통계 기반 기법’ 과 신경망을 사용한 ‘추론 기반 기법’ 에 데하여 알아보겠습니다.

---

통계 기반 기법

우리는 통계 기반 기법을 사용하면서 Corpus(말뭉치)를 이용할겁니다.

• Corpus는 간단히 말하면 대량의 Test Data입니다.
• 다만 Corpus는 NLP연구에서의 염두를 두고 수집된 Test Data를 일반적으로 "Corpus(말몽치)" 라고 합니다.
• 또한 통계 기반 기법의 목표는 이처럼 사람의 지식으로 가득한 Corpus(말뭉치)에서 자동으로, 효율적으로 그 핵심을 추출하는 것입니다.

자연어 처리에 사용되는 말뭉치에는 텍스트 데이터에 대한 추가 정보가 포함되는 경우가 있 습니다
예컨대 텍스트 데이터의 단어 각각에 ‘품사’가 레이블링될 수 있습니다
이럴 경우 말뭉차는 컴퓨터가 다루기 쉬운 형태 트리 구조로 가공되어 주어자는 것이 일반적입니다
이 글에서는 단순한 텍스트 데이터하나의 큰 텍스트 파일)로 주어졌다고 가정합니다

 

 

Corpus(말뭉치) 전처리 하기 by Python

자연어 처리에는 다양한 말뭉치가 사용됩니다

• 유명한 것으로는 위키백과Wikipedia와 구글 뉴스Google News 등의 텍스트 데이터를 들 수 있죠
• 또한 셰익스피어나 나쓰메 소세키 같은 대문호 의 작품들도 말뭉치로 이용됩니다
• 이번에는 문장 하나로 이뤄진 단순한 텍스트를 사용합니다. 한번 해보겠습니다.

text = 'You say goodbye and I say hello.'

 

• 이처럼 문장 하나로 이뤄진 텍스트를 Corpus(말뭉치)로 이용합니다.
• 실전이라면 이 text에 수천 ,만 개가 넘는 문장이 (연이어) 담겨 있을 것입니다.
• 다만, 쉽게 설명하기 위해서 이 작은 텍스트 데이터 만으로 전처리를 해보겠습니다.
• 먼저 text를 단어 단위로 나눠보겠습니다.

text = text.lower()
text = text.replace('.’, '.')
text

'you say goodbye and i say hello.'

words = text.split(' ')
words
['you','say','goodbye', ‘and’, 'i', 'say', 'hello', '.']

 

• lower() Method를 사용하여 문자를 소문자로 변환합니다.
• 그리고 split() Method를 이동하여 공백을 기준으로 분할합니다.
• 이제 원래의 문장을 단어 목록 형태로 이용할 수 있게 되었습니다.
• 단어 단위로 분할되어 다루기가 쉬워진 것은 사실이지만, 단어를 텍스트 그대로 조작하기란 여러 면에서 불편합니다.
• 그래서 단어에 ID를 부여하고, ID의 리스트로 이용할 수 있도록 한 번 더 손질합니다.
• 이를 위한 사전 준비로, 파이썬의 딕셔너리를 이용하여 단어 ID와 단어를 짝지어주는 대응표를 작성합니다.

>>> word_to_id = {}
>>> id_to_word = {}

>>> for word in words:
...     if word not in word_to_id:
...         new_id = len(word_to_id)
...         word_to_id[word] = new_id
...         id_to_word[new_id] = word

 

• 단어 ID에서 단어로의 변환은 id_to_word가 담당하며(키가 단어 ID, 값이 단어), 단어에서 단어 ID로의 변환은 word_to_id가 담당합니다.
• 앞의 코드는 단어 단위로 분할된 words의 각 원소를 처음부터 하나씩 살펴보면서, 단어가 word_to_id에 들어 있지 않으면 word_to_id와 id_to_word 각각에 새로운 ID와 단어를 추가합니다.
• 또한 추가 시점의 딕셔너리 길이가 새로운 단어의 ID로 설정되기 때문에 단어 ID는 0, 1, 2, … 식으로 증가합니다.
• 아래는 단어 ID와 단어의 대응표입니다.

>>> id_to_word
{0: 'you', 1: 'say', 2: 'goodbye', 3: 'and', 4: 'i', 5: 'hello', 6: '.'}
>>> word_to_id
{'you': 0, 'say': 1, 'goodbye': 2, 'and': 3, 'i': 4, 'hello': 5, '.': 6}

 

• 이처럼 딕셔너리를 사용하면 단어를 가지고 단어 ID를 검색하거나, 반대로 단어 ID를 가지고 단어를 검색할 수 있습니다.

>>> id_to_word[1]
'say'
>>> word_to_id['hello']
5

 

• 그럼 마지막으로 ‘단어 목록’을 ‘단어 ID 목록’으로 변경해봅시다.
• 다음 코드에서는 파이썬의 내포 comprehension 표기를 사용하여 단어 목록에서 단어 ID 목록으로 변환한 다음, 다시 넘파이 배열로 변환했습니다.

내포란 리스트나 딕셔너리 등의 반복문 처리를 간단하게 쓰기 위한 기법입니다.

>>> import numpy as np
>>> corpus = [word_to_id[w] for w in words]
>>> corpus = np.array(corpus)
>>> corpus
array([0, 1, 2, 3, 4, 1, 5, 6])

 

• 이것으로 Corups(말뭉치)를 이용하기 위한 사전 준비를 마쳤습니다.
• 이러한 처리를 한 데 모아 preprocess()라는 함수로 구현해 보겠습니다.

def preprocess(text):
    text = text.lower()
    text = text.replace('.', ' .')
    words = text.split(' ')

    word_to_id = {}
    id_to_word = {}
    for word in words:
        if word not in word_to_id:
            new_id = len(word_to_id)
            word_to_id[word] = new_id
            id_to_word[new_id] = word

    corpus = np.array([word_to_id[w] for w in words])

    return corpus, word_to_id, id_to_word

• 이 함수를 사용하면 Corpus(말뭉치) 전처리를 다음과 같이 수행할 수 있습니다.

>>> text = 'You say goodbye and I say hello.'
>>> corpus, word_to_id, id_to_word = preprocess(text)

• 이것으로 말뭉치 전처리가 끝났습니다.
• corpus는 단어 ID 목록, word_to_id는 단어에서 단어 ID로의 딕셔너리, id_to_word는 단어 ID에서 단어로의 딕셔너리를 뜻합니다.
• 이상으로 말뭉치를 다룰 준비를 마쳤습니다.

 

단어의 분산 표현

• 세상의 다양한 색을 고유한 이름으로 부를 수도 있지만, RGB와 같은 벡터로 표현하면 더 정확하고 간결하게 표현할 수 있습니다.
• 이와 마찬가지로, 단어도 Vector(벡터)로 표현하여 그 의미를 정량화하고 관련성을 파악할 수 있습니다.
• 이러한 단어의 벡터 표현을 '분산 표현'이라고 하며, 이는 자연어 처리 분야에서 단어의 의미를 효과적으로 파악하기 위해 중요한 방법입니다.

 

Distributional Hypothesis - 분포 가설

최근의 NLP 연구들을 살펴보면, 중요한 기법들이 하나의 간단한 아이디어에 기반하고 있습니다.
바로 '단어의 의미는 주변 단어에 의해 형성된다' 라는 것입니다. 이를 분포 가설 distributional hypothesis 이라고 합니다.

 

• 분포 가설이 말하고자 하는 바는 매우 간단합니다.
• 단어 자체에는 의미가 없고, 그 단어가 사용된 ‘맥락’(context)이 의미를 형성한다는 것이죠.
• 물론 의미가 같은 단어들은 같은 맥락에서 더 많이 등장합니다.
• 예를 들어 "I drink beer"와 "We drink wine"처럼 "drink"의 주변에는 음료가 등장하기 쉬울 것입니다. 
• 아래의 그림은 좌우의 두 단어씩이 '맥락'에 해당합니다.

window 크기가 2인 '맥략'의 예. 단어 'goodbye'에 주목한다면, 그 좌우의 두 단어(총 4단어)를 맥락으로 이용한다.

• ‘맥락’이란 특정 단어를 중심에 둔 그 주변 단어를 말합니다.
• 그리고 맥락의 크기(주변 단어를 몇 개나 포함할지)를 ‘윈도우 크기’(window size)라고 합니다.
• 윈도우 크기가 1이면 좌우 한 단어씩이, 윈도우 크기가 2이면 좌우 두 단어씩이 맥락에 포함됩니다.

 

Co-occurence Matrix - 동시발생 행렬

Co-occurence Matrix(동시 발생 행렬)은 어떤 단어를 주목했을때, 그 주번에 어떤 단어가 몇 번이나 등장하는지를 세어 집계하는 방법입니다.

• 한번 코드로 살펴 보겠습니다.

import sys
sys.path.append('..')
import numpy as np
from common.util import preprocess

text = 'You say goodbye and I say hello.'
corpus, word_to_id, id_to_word = preprocess(text)

print(corpus)
# [0 1 2 3 4 1 5 6]

print(id_to_word)
# {0: 'you', 1: 'say', 2: 'goodbye', 3: 'and', 4: 'i', 5: 'hello', 6: '.'}

• preprocess 함수를 사용하여 텍스트 데이터를 전처리합니다.
• 먼저, 필요한 모듈을 임포트하고 preprocess 함수를 정의한 후, 예제 텍스트를 전처리하여 단어 ID로 변환된 말뭉치와 단어-ID 매핑 딕셔너리를 생성합니다.
• 이를 통해 텍스트 데이터를 벡터 형태로 변환합니다.
• 결과를 보면 단어수가 7개임을 알 수 있습니다.

 

• 이번에는 한번 각 단어의 맥략에 해당하는 단어의 빈도를 세어보겠습니다.
• Window 크기는 1로 하고, 단어 ID가 0인 "you"부터 보겠습니다.

단어 "you" 의 맥락을 세어봅니다.

• 위의 그림에서 볼 수 있듯, 단어 "you"의 맥략은 "say" 하나 뿐입니다. 이를 표로 표현하면 아래와 표 처럼 나옵니다.

단어 "you"에 맥략에 포함되는 단어의 빈도를 표로 정리한다.

• 단어 "you"의 맥략으로써 동시에 발생(등장)하는 단어의 빈도를 나타내었습니다.
• 그리고 이를 바탕으로 "you"라는 단어를 [0, 1, 0, 0, 0, 0. 0]이라는 벡터로 표현할 수 있습니다.
• 그리고 ID가 1인 "say"에 대해서도 같은 작업을 수행합니다. 결과는 아래에서 볼 수 있습니다.

단어 "say"의 맥략에 포함되는 단어의 빈도를 표로 정리한것 입니다.

• 이렇게 "say"라는 단어는 Vector [1, 0, 1, 0, 1, 1, 0]으로 표현할 수 있습니다.
• 이 모든 작업을 수행한 결과는 아래의 표과 같습니다.
• 이 표는 모든 단어에 데해 동시발생하는 단어를 표에 정리한 것입니다. 이 표의 각 행은 해당 단어를 표현한 Vector가 됩니다.
• 그리고 이 표가 Matrix(행렬)의 형태를 띤다는 뜻에서 Co-occurence Matrix(동시발생 행렬)이라고 합니다. 한번 Python으로 구현해보겠습니다.

C = np.array([
    [0, 1, 0, 0, 0, 0, 0],
    [1, 0, 1, 0, 1, 1, 0],
    [0, 1, 0, 1, 0, 0, 0],
    [0, 0, 1, 0, 1, 0, 0],
    [0, 1, 0, 1, 0, 1, 0],
    [0, 1, 0, 0, 1, 0, 1],
], dtype=np.int32)

 

• 이 Co-occurence Matrix(동시발생 행렬)을 사용하면 다음과 같은 방식으로 각 단어의 Vector를 얻을 수 있습니다.

print(C[0])  # ID가 0인 단어의 벡터 표현
# [0 1 0 0 0 0 0]

print(C[4])  # ID가 4인 단어의 벡터 표현
# [0 1 0 1 0 1 0]

print(C[word_to_id['goodbye']])  # "goodbye"의 벡터 표현
# [0 1 0 1 0 1 0]

 

• Co-occurence Matrix(동시발생 행렬)을 활용하면 단어를 Vector로 나타낼 수 있습니다.
• 그리고 Co-occurence Matrix(동시발생 행렬)을 자동화할 수도 있습니다.
• 그러면 Corpus(말뭉치)로부터 동시발생 행렬을 만들어주는 함수를 구현해봅시다.
• 인수들은 차례로 단어 ID의 corpus(리스트), vocab_size(어휘 수), window_size=1(윈도우 크기)를 나타냅니다.

def create_co_matrix(corpus, vocab_size, window_size=1):
    # 말뭉치(corpus)의 크기를 계산
    corpus_size = len(corpus)
    # 동시발생 행렬을 0으로 초기화. 크기는 (어휘 수, 어휘 수)
    co_matrix = np.zeros((vocab_size, vocab_size), dtype=np.int32)

    # 말뭉치의 각 단어에 대해 반복
    for idx, word_id in enumerate(corpus):
        # 현재 단어의 좌우 window_size 범위 내의 단어들을 확인
        for i in range(1, window_size + 1):
            left_idx = idx - i
            right_idx = idx + i

            # 좌측 윈도우 인덱스가 0 이상일 경우
            if left_idx >= 0:
                # 좌측 단어의 ID를 가져와 동시발생 행렬을 업데이트
                left_word_id = corpus[left_idx]
                co_matrix[word_id, left_word_id] += 1

            # 우측 윈도우 인덱스가 말뭉치 크기보다 작을 경우
            if right_idx < corpus_size:
                # 우측 단어의 ID를 가져와 동시발생 행렬을 업데이트
                right_word_id = corpus[right_idx]
                co_matrix[word_id, right_word_id] += 1

    # 최종 동시발생 행렬 반환
    return co_matrix

 

• 이 함수는 먼저 co_matrix를 0으로 채워진 2차원 Array로 초기화합니다.
• 그다음은 Corpus의 모든 단어 각각에 대하여 Window에 포함된 주변 단어를 세어나갑니다.
• 이때 Corpus의 왼쪽 끝과 오른쪽 끝 경계를 벗어나지 않는지도 확인합니다.

---

 

Vector간 유사도

한번 Vector 사이의 유사도를 측정하는 방법을 살펴보겠습니다.

• Vector(벡터) 사이의 유사도를 표현할 때는 Cosine Similarity(코사인 유사도)를 자주 이용합니다.
• 두 벡터 𝑥=(𝑥1,𝑥2,𝑥3,⋯ ,𝑥𝑛)과 y=(y1​,y2​,y3​,⋯,yn​)이 있다면, 코사인 유사도는 다음 식으로 정의됩니다.

• 분자에는 Vector(벡터)의 내적이, 분모에는 각 Vector(벡터)의 노름(norm)이 등장합니다.
• 노름은 Vector(벡터)의 크기를 나타낸 것으로, 여기서는 L2 노름을 계산합니다 (L2 노름은 벡터의 각 원소를 제곱해 더한 후 다시 제곱근을 구해 계산합니다).
• 이식의 핵심은 Vector(벡터)를 정규화하고 내적을 구하는 것입니다.

코사인 유사도를 직관적으로 풀어보자면 ‘두 벡터가 가리키는 방향이 얼마나 비슷한가’입니다.
두 벡터의 방향이 완전히 같으면 코사인 유사도가 1이 되며, 완전히 반대라면 -1이 됩니다.

 

• 그러면 이제 Cosine Similarity(코사인 유사도)를 Python 함수로 구현해 보겠습니다.

def cos_similarity(x, y):
    nx = x / np.sqrt(np.sum(x**2))  # x의 정규화
    ny = y / np.sqrt(np.sum(y**2))  # y의 정규화
    return np.dot(nx, ny)

 

• 함수는 먼저 벡터 x와 y를 정규화한 후 두 Vector(벡터)의 내적을 구했습니다.
• 이렇게만 해도 Cosine Similarity(코사인 유사도)를 구할 수 있습니다만, 사실 이 구현에는 문제가 하나 있습니다.
• 인수로 Zero Vector(제로 벡터 - 원소가 모두 0인 Vector)가 들어오면 0으로 나누기(divide by zero) 오류가 발생합니다.
• 이 문제를 해결하는 전통적인 방법은 나눗셈 분모에 작은 값을 더해주는 것입니다. 아래는 개선된 코드 입니다.

def cos_similarity(x, y, eps=1e-8):
    nx = x / (np.sqrt(np.sum(x ** 2)) + eps)
    ny = y / (np.sqrt(np.sum(y ** 2)) + eps)
    return np.dot(nx, ny)

 

• 아래는 최종적으로 단어 "you"와 "i"의 유사도를 구하는 코드입니다.

import sys
sys.path.append('..')
from common.util import preprocess, create_co_matrix, cos_similarity

text = 'You say goodbye and I say hello.'
corpus, word_to_id, id_to_word = preprocess(text)
vocab_size = len(word_to_id)
C = create_co_matrix(corpus, vocab_size)

c0 = C[word_to_id['you']]  # "you"의 단어 벡터
c1 = C[word_to_id['i']]  # "i"의 단어 벡터
print(cos_similarity(c0, c1))
# 0.7071067691154799

실행 결과 "you"와 "i"의 코사인 유사도는 0.70...으로 나왔습니다
코사인 유사도 값은 -1에서 1 사이이므로, 이 값은 비교적 높다(유사성이 크다)고 말할 수 있습니다.

---

유사 단어의 랭킹 표시

어떤 단어가 검색어로 주어지면, 그 검색어와 비슷한 단어를 유사도 순으로 출력하는 함수는 어떨까요?
그 함수 이름은 most_similar()로 하고, 다음 인수들을 입력받도록 구현해봅시다.

most_similar(query, word_to_id, id_to_word, word_matrix, top=5)

• most_similar() 함수의 인수

인수명	설명
query	검색어(단어)
word_to_id	단어에서 단어 ID로의 딕셔너리
id_to_word	단어 ID에서 단어로의 딕셔너리
word_matrix	단어 벡터들을 한데 모은 행렬. 각 행에는 대응하는 단어의 벡터가 저장되어 있다고 가정한다.
top	상위 몇 개까지 출력할지 설정

• most_similar() 함수의 구현은 다음과 같습니다.

def most_similar(query, word_to_id, id_to_word, word_matrix, top=5):
    # 1. 검색어를 꺼낸다.
    if query not in word_to_id:
        print('%s(을)를 찾을 수 없습니다.' % query)
        return

    print('\n[query] ' + query)
    query_id = word_to_id[query]
    query_vec = word_matrix[query_id]

    # 2. 코사인 유사도 계산
    vocab_size = len(id_to_word)
    similarity = np.zeros(vocab_size)
    for i in range(vocab_size):
        similarity[i] = cos_similarity(word_matrix[i], query_vec)

    # 3. 코사인 유사도를 기준으로 내림차순으로 출력
    count = 0
    for i in (-1 * similarity).argsort():
        if id_to_word[i] == query:
            continue
        print(' %s: %s' % (id_to_word[i], similarity[i]))

        count += 1
        if count >= top:
            return

• 이 코드의 동작순서는 아래와 같이 동작합니다.

1. 검색어의 단어 벡터를 꺼냅니다.
2. 검색어의 단어 벡터와 다른 모든 단어 벡터와의 코사인 유사도를 각각 구합니다.
3. 계산한 코사인 유사도 결과를 기준으로 값이 높은 순서대로 출력합니다.

 

• 3번째 코드에 부분에 데한 설명을 조금만 덧붙이면, similarity 배열에 담긴 원소의 인덱스를 내림차순으로 정렬한 후 상위 원소들을 출력합니다.
• 이때 배열 인덱스의 정렬을 바꾸는 데 사용한 argsort() 메서드는 넘파이 배열의 원소를 오름차순으로 정렬합니다.
• 아래는 argsort() Method의 사용 예시 입니다.

>>> x = np.array([100, -20, 2])
>>> x.argsort()
array([1, 2, 0])

• 이처럼 argsort()를 사용하면 단어의 유사도가 높은 순서로 출력할 수 있습니다.
• 이것이 most_similar() 함수의 구현입니다. 한번 "you"를 검색어로 지정해 유사한 단어들을 출력해보겠습니다.

import sys
sys.path.append('..')  # 상위 디렉토리를 모듈 검색 경로에 추가
from common.util import preprocess, create_co_matrix, most_similar  # 필요한 함수들 임포트

# 입력 텍스트
text = 'You say goodbye and I say hello.'

# 텍스트 전처리: 단어 목록과 단어-인덱스 매핑, 인덱스-단어 매핑 생성
corpus, word_to_id, id_to_word = preprocess(text)

# 어휘 사전의 크기
vocab_size = len(word_to_id)

# 동시발생 행렬 생성
C = create_co_matrix(corpus, vocab_size)

# 특정 단어와 유사한 단어들을 찾고 출력 (여기서는 'you'와 유사한 단어들)
most_similar('you', word_to_id, id_to_word, C, top=5)

• 아래의 코드의 실행 결과 입니다.

[query] you
goodbye: 0.7071067691154799
i: 0.7071067691154799
hello: 0.7071067691154799
say: 0.0
and: 0.0

• 이 결과는 검색어 "you"와 유사한 단어를 상위 5개만 출력한 것입니다.
• Cosine Similarity(코사인 유사도)는 해당 단어의 오른쪽에서 볼 수 있습니다.
• 결과를 보면 "you"에 가장 가까운 단어는 총 3개인데, 차례로 "goodbye", "i(=나)", "hello"입니다.
• 확실히 "i"와 "you" 모두 인칭대명사이므로 둘이 비슷하다는 건 납득이 됩니다.
• 하지만 "goodbye"와 "hello"의 Cosine Similarity(코사인 유사도)가 높다는 것은 우리의 직관과는 거리가 멀죠.
• 이유는 지금은 Corpus(말뭉치), 즉 데이터셋의 크기가 너무 작다는 것이 원인이라고 볼 수 있을것 같습니다.

---

Summary

WordNet 등의 Thesaursus를 이용하면 유의어를 얻거나 단어 사이의 유사도를 측정하는 등 유용한 작업을 할 수 있다.
Thesaursus 기반 기법은 Thesaursus를 작성하는 데 엄청난 인적 자원이 든다거나 새로운 단어에 대응하기 어렵다는 문제가 있다.
현재는 Corpus(말뭉치)를 이용해 단어를 Vector화하는 방식이 주로 쓰인다.
최근의 단어 Vector화 기법들은 대부분 '단어의 의미는 주변 단어에 의해 형성된다'는 분포 가설에 기초한다.
통계 기반 기법은 Corpus(말뭉치) 안의 각 단어에 대해서 그 단어의 주변 단어의 빈도를 집계한다 (Co-Occurance Matrix).