[NLP] Pytorch를 활용하여 CBOW 임베딩 학습하기 (1)데이터셋 생성

-- 본 포스팅은 파이토치로 배우는 자연어 처리 (한빛미디어) 책을 참고해서 작성된 글입니다.
-- 소스코드는 여기

 

1. CBOW 란

• Word2Vec CBOW 모델
• 다중 분류 작업
• 단어를 스캔하여 단어의 문맥 Window를 만든 후 문맥 Window에서 중앙의 단어를 제거하고 문맥 WIndow를 활용하여 누락 단어를 예측하는 모델
• 단어가 누락된 문장에서 누락 단어가 무엇인지 파악하는 역할을 수행

 

2. 활용 데이터

• http://bit.ly/2T5iU8J 에서 메리 셸리의 소설 [프랑켄슈타인]의 디지털 버전을 받아 구축한 텍스트 데이터셋 활용
• 파이토치의 Dataset 클래스를 만들고 마지막에 데이터를 훈련, 검증, 테스트 세트로 분할하여 사용

 

3. 데이터 전처리

3.1 텍스트를 개별 문장으로 분할

# Split the raw text book into sentences
tokenizer = nltk.data.load('tokenizers/punkt/english.pickle')
with open(args.raw_dataset_txt) as fp:
    book = fp.read()
sentences = tokenizer.tokenize(book)

print (len(sentences), "sentences")
print ("Sample:", sentences[100])

 

3.2 다음 각 문장을 소문자로 변환하고 구두점을 완전히 제거

• 정규식을 활용하여 제거해주고, 공백으로 문자열을분할하여 토큰 리스트를 추출

# Clean sentences
def preprocess_text(text):
    text = ' '.join(word.lower() for word in text.split(" "))
    text = re.sub(r"([.,!?])", r" \1 ", text)
    text = re.sub(r"[^a-zA-Z.,!?]+", r" ", text)
    return text
    

cleaned_sentences = [preprocess_text(sentence) for sentence in sentences]

 

3.3 데이터를 윈도우 시퀀스로 표현

• CBOW모델을 최적화 할 수 있도록 데이터셋을 window의 시퀀스로 표현

'''
# 이전에 설정해둔 파라미터 확인하기
args = Namespace(
    raw_dataset_txt="data/books/frankenstein.txt",
    window_size=5,
    train_proportion=0.7,
    val_proportion=0.15,
    test_proportion=0.15,
    output_munged_csv="data/books/frankenstein_with_splits.csv",
    seed=1337
)

'''

# Global vars
MASK_TOKEN = "<MASK>"

# 윈도우로 만들어주기 (window size = 5)
# 각 문장의 토큰 리스트를 순회하면서 지정된 크기의 window로 묶어주기
flatten = lambda outer_list: [item for inner_list in outer_list for item in inner_list]
windows = flatten([list(nltk.ngrams([MASK_TOKEN] * args.window_size + sentence.split(' ') + \
    [MASK_TOKEN] * args.window_size, args.window_size * 2 + 1)) \
    for sentence in tqdm_notebook(cleaned_sentences)])

# CBOW 데이터로 만들어주기
data = []
for window in tqdm_notebook(windows):
    target_token = window[args.window_size]
    context = []
    for i, token in enumerate(window):
        if token == MASK_TOKEN or i == args.window_size:
            continue
        else:
            context.append(token)
    data.append([' '.join(token for token in context), target_token])
    
            
# DataFrame의 형태로 변환
cbow_data = pd.DataFrame(data, columns=["context", "target"])

▶ 지정된 크기의 Window로 묶어준다는 말을 그림으로 표현하면 아래와 같다.

파이토치로 배우는 자연어 처리 

• CBOW 작업은 위 그림과 같다.
• 왼쪽문맥과 오른쪽 문맥을 사용하여 (빨간단어)를 예측한다. 
• 문맥의 윈도우 길이는 양쪽으로 2임을 볼 수 있다.
• 텍스트 위를 슬라이딩하는 윈도우가 지도학습 샘플을 생성한다. 
• 각 샘플의 타깃은 (빨간단어) 이고, 샘플은 윈도우에 있는 나머지 단어이다.
• 길이가 2가안되는 window는 적절하게 패딩된다.

 

3.4 데이터 분할

• 데이터를 train 70%, validation 15%, test 15%로 분할할 것이다. (이전에 args에서 지정)
• 훈련train 세트는 파라미터를 업데이트하는데 사용하고
• 검증val 세트는 모델의 성능을 측정하는데 사용된다.
• 테스트test 세트는 마지막에 가장 좋은 모델에 딱 한번만 사용된다.

# Create split data
n = len(cbow_data)
def get_split(row_num):
    if row_num <= n*args.train_proportion:
        return 'train'
    elif (row_num > n*args.train_proportion) and (row_num <= n*args.train_proportion + n*args.val_proportion):
        return 'val'
    else:
        return 'test'
cbow_data['split']= cbow_data.apply(lambda row: get_split(row.name), axis=1)


cbow_data.head()

 

2. Dataset class 

전체코드 더보기 클릭

class CBOWDataset(Dataset):
    # CBOWDataset의 생성자 메서드
    # CBOWDataset은 결국 cbow데이터셋과 vectorizer를 생성한다!
    def __init__(self, cbow_df, vectorizer):
        """
        매개변수:
            cbow_df (pandas.DataFrame): 데이터셋
            vectorizer (CBOWVectorizer): 데이터셋에서 만든 CBOWVectorizer 객체
        """
        self.cbow_df = cbow_df
        self._vectorizer = vectorizer
        
        measure_len = lambda context: len(context.split(" "))
        # cbow df 데이터중 가장 긴 것을 시퀀스의 길이로 설정한다
        self._max_seq_length = max(map(measure_len, cbow_df.context))
        
        self.train_df = self.cbow_df[self.cbow_df.split=='train']
        self.train_size = len(self.train_df)

        self.val_df = self.cbow_df[self.cbow_df.split=='val']
        self.validation_size = len(self.val_df)

        self.test_df = self.cbow_df[self.cbow_df.split=='test']
        self.test_size = len(self.test_df)

        self._lookup_dict = {'train': (self.train_df, self.train_size),
                             'val': (self.val_df, self.validation_size),
                             'test': (self.test_df, self.test_size)}

        self.set_split('train')

    @classmethod
    def load_dataset_and_make_vectorizer(cls, cbow_csv):
        """데이터셋을 로드하고 처음부터 새로운 Vectorizer 만들기
        
        매개변수:
            cbow_csv (str): 데이터셋의 위치
        반환값:
            CBOWDataset의 인스턴스
        """
        cbow_df = pd.read_csv(cbow_csv)
        train_cbow_df = cbow_df[cbow_df.split=='train']
        # from_dataframe : vocabulary 클래스로부터 vocab을 받아오고, 해당 vocab을 사용해서 단어에 정수를 매핑해준다.
        #                : 반환값은 단어에 정수가 매핑된 cbow_vocab 이다.
        #                  --> 즉 이것이 vectorizer이고 cls의 매개변수로 들어가게 된다.
        return cls(cbow_df, CBOWVectorizer.from_dataframe(train_cbow_df))

    @classmethod
    def load_dataset_and_load_vectorizer(cls, cbow_csv, vectorizer_filepath):
        """ 데이터셋을 로드하고 새로운 CBOWVectorizer 객체를 만듭니다.
        캐시된 CBOWVectorizer 객체를 재사용할 때 사용합니다.
        
        매개변수:
            cbow_csv (str): 데이터셋의 위치
            vectorizer_filepath (str): CBOWVectorizer 객체의 저장 위치
        반환값:
            CBOWVectorizer의 인스턴스
        """
        cbow_df = pd.read_csv(cbow_csv)
        # load_vectorizer_only : vectorizer의 파일을 받아와서 cbow_vocab (정수가 매핑된 단어)를 반환한다.
        #                          --> 즉 이것이 vectorizer이고 cls의 매개변수로 들어가게 된다.
        vectorizer = cls.load_vectorizer_only(vectorizer_filepath)
        return cls(cbow_df, vectorizer)

    @staticmethod
    def load_vectorizer_only(vectorizer_filepath):
        """파일에서 CBOWVectorizer 객체를 로드하는 정적 메서드
        
        매개변수:
            vectorizer_filepath (str): 직렬화된 CBOWVectorizer 객체의 위치
        반환값:
            CBOWVectorizer의 인스턴스
        """
        with open(vectorizer_filepath) as fp:
            # from_serializable() : vocab을 받아와서 정수가 매핑된 vocab을 얻는다. 
            #                        ---> 즉, 이게 vectorizer
            return CBOWVectorizer.from_serializable(json.load(fp))

    def save_vectorizer(self, vectorizer_filepath):
        """CBOWVectorizer 객체를 json 형태로 디스크에 저장합니다 
        매개변수:
            vectorizer_filepath (str): CBOWVectorizer 객체의 저장 위치
        """
        with open(vectorizer_filepath, "w") as fp:
            json.dump(self._vectorizer.to_serializable(), fp)

    def get_vectorizer(self):
        """ 벡터 변환 객체를 반환합니다 """
        return self._vectorizer
        
    def set_split(self, split="train"):
        """ 데이터프레임에 있는 열을 사용해 분할 세트를 선택합니다 """
        self._target_split = split
        self._target_df, self._target_size = self._lookup_dict[split]

    def __len__(self):
        return self._target_size

    def __getitem__(self, index):
        """파이토치 데이터셋의 주요 진입 메서드
        
        매개변수:
            index (int): 데이터 포인트의 인덱스
        반환값:
            데이터 포인트의 특성(x_data)과 레이블(y_target)로 이루어진 딕셔너리
        """
        row = self._target_df.iloc[index]

        context_vector = \
            self._vectorizer.vectorize(row.context, self._max_seq_length)
        target_index = self._vectorizer.cbow_vocab.lookup_token(row.target)

        return {'x_data': context_vector,
                'y_target': target_index}

    def get_num_batches(self, batch_size):
        """배치 크기가 주어지면 데이터셋으로 만들 수 있는 배치 개수를 반환합니다
        
        매개변수:
            batch_size (int)
        반환값:
            배치 개수
        """
        return len(self) // batch_size
    
def generate_batches(dataset, batch_size, shuffle=True,
                     drop_last=True, device="cpu"): 
    """
    파이토치 DataLoader를 감싸고 있는 제너레이터 함수.
    걱 텐서를 지정된 장치로 이동합니다.
    """
    dataloader = DataLoader(dataset=dataset, batch_size=batch_size,
                            shuffle=shuffle, drop_last=drop_last)

    for data_dict in dataloader:
        out_data_dict = {}
        for name, tensor in data_dict.items():
            out_data_dict[name] = data_dict[name].to(device)
        yield out_data_dict

만들어진 데이터셋과 타겟은 pandas dataframe 형태로 로드되고, CBOWDataset클래스에서 인덱싱 된다.

2.1 Dataset 클래스 내부 메서드 살펴보기

▶ 생성자 메서드 __init__(self, cbow_df, vectorizer)

• cbow 데이터셋(train, val, test df)과 데이터셋에서 만든  vectorizer 객체를 생성한다.

    # CBOWDataset의 생성자 메서드
    # CBOWDataset은 결국 cbow데이터셋과 vectorizer를 생성한다!
    def __init__(self, cbow_df, vectorizer):
        """
        매개변수:
            cbow_df (pandas.DataFrame): 데이터셋
            vectorizer (CBOWVectorizer): 데이터셋에서 만든 CBOWVectorizer 객체
        """
        self.cbow_df = cbow_df
        self._vectorizer = vectorizer
        
        measure_len = lambda context: len(context.split(" "))
        # cbow df 데이터중 가장 긴 것을 시퀀스의 길이로 설정한다
        self._max_seq_length = max(map(measure_len, cbow_df.context))
        
        self.train_df = self.cbow_df[self.cbow_df.split=='train']
        self.train_size = len(self.train_df)

        self.val_df = self.cbow_df[self.cbow_df.split=='val']
        self.validation_size = len(self.val_df)

        self.test_df = self.cbow_df[self.cbow_df.split=='test']
        self.test_size = len(self.test_df)

        self._lookup_dict = {'train': (self.train_df, self.train_size),
                             'val': (self.val_df, self.validation_size),
                             'test': (self.test_df, self.test_size)}

        self.set_split('train')

 

▶ load_dataset_and_make_vectorizer(cls, cbow_csv)
▶ load_dataset_and_load_vectorizer(cls, cbow_csv, vectorizer_filepath)

• make
  • vectorizer가 존재하지 않을 떄 해당 메서드를 사용한다.
  • cbow csv 파일을 받아와서 vectorizer 객체를 만들어주는 메서드
    • return 값을 보면, vetorizer 객체를 만들어서 다시 cls함수에 넣어주기 떄문에 결국 Dataset의 인스턴스가 반환값이라고 할 수 있다.
  • cbow_csv 매개변수에는 파일의 위치를 받는다.
  • dataset = CBOWDataset.load_dataset_and_make_vectorizer(args.cbow_csv) 이렇게 데이터셋을 생성하게 된다.
• load
  • 이미 vectorizer 객체가 존재한다면 해당 메서드를 사용한다.
  • cbow csv 파일과 vectorizer 파일을 받아와서 사용하도록 되어있다.
  • make와 마찬가지로 결국 cls로 들어가기 때문에 dataset의 인스턴스로 반환된다고 생각하면 된다.
  • dataset = CBOWDataset.load_dataset_and_load_vectorizer(args.cbow_csv) 이렇게 두개의 파일을 로드하게 된다.

    @classmethod
    def load_dataset_and_make_vectorizer(cls, cbow_csv):
        """데이터셋을 로드하고 처음부터 새로운 Vectorizer 만들기
        
        매개변수:
            cbow_csv (str): 데이터셋의 위치
        반환값:
            CBOWDataset의 인스턴스
        """
        cbow_df = pd.read_csv(cbow_csv)
        train_cbow_df = cbow_df[cbow_df.split=='train']
        # from_dataframe : vocabulary 클래스로부터 vocab을 받아오고, 해당 vocab을 사용해서 단어에 정수를 매핑해준다.
        #                : 반환값은 단어에 정수가 매핑된 cbow_vocab 이다.
        #                  --> 즉 이것이 vectorizer이고 cls의 매개변수로 들어가게 된다.
        return cls(cbow_df, CBOWVectorizer.from_dataframe(train_cbow_df))

    @classmethod
    def load_dataset_and_load_vectorizer(cls, cbow_csv, vectorizer_filepath):
        """ 데이터셋을 로드하고 새로운 CBOWVectorizer 객체를 만듭니다.
        캐시된 CBOWVectorizer 객체를 재사용할 때 사용합니다.
        
        매개변수:
            cbow_csv (str): 데이터셋의 위치
            vectorizer_filepath (str): CBOWVectorizer 객체의 저장 위치
        반환값:
            CBOWVectorizer의 인스턴스
        """
        cbow_df = pd.read_csv(cbow_csv)
        # load_vectorizer_only : vectorizer의 파일을 받아와서 cbow_vocab (정수가 매핑된 단어)를 반환한다.
        #                          --> 즉 이것이 vectorizer이고 cls의 매개변수로 들어가게 된다.
        vectorizer = cls.load_vectorizer_only(vectorizer_filepath)
        return cls(cbow_df, vectorizer)

 

▶ load_vectorizer_only(vectorizer_filepath)
▶ save_vectorizer(self, vectorier_filepath)
▶ get_vectorizer(self)
▶ set_split(self, split='train')
▶ get_num_batches(self, batch_size)

    @staticmethod
    def load_vectorizer_only(vectorizer_filepath):
        """파일에서 CBOWVectorizer 객체를 로드하는 정적 메서드
        
        매개변수:
            vectorizer_filepath (str): 직렬화된 CBOWVectorizer 객체의 위치
        반환값:
            CBOWVectorizer의 인스턴스
        """
        with open(vectorizer_filepath) as fp:
            # from_serializable() : vocab을 받아와서 정수가 매핑된 vocab을 얻는다. 
            #                        ---> 즉, 이게 vectorizer
            return CBOWVectorizer.from_serializable(json.load(fp))

    def save_vectorizer(self, vectorizer_filepath):
        """CBOWVectorizer 객체를 json 형태로 디스크에 저장합니다 
        매개변수:
            vectorizer_filepath (str): CBOWVectorizer 객체의 저장 위치
        """
        with open(vectorizer_filepath, "w") as fp:
            json.dump(self._vectorizer.to_serializable(), fp)

    def get_vectorizer(self):
        """ 벡터 변환 객체를 반환합니다 """
        return self._vectorizer
        
    def set_split(self, split="train"):
        """ 데이터프레임에 있는 열을 사용해 분할 세트를 선택합니다 """
        self._target_split = split
        self._target_df, self._target_size = self._lookup_dict[split]
        
    def get_num_batches(self, batch_size):
        """배치 크기가 주어지면 데이터셋으로 만들 수 있는 배치 개수를 반환합니다
        
        매개변수:
            batch_size (int)
        반환값:
            배치 개수
        """
        return len(self) // batch_size

 

▶ __len__ / __getitem__ 메서드

    def __len__(self):
        return self._target_size

    def __getitem__(self, index):
        """파이토치 데이터셋의 주요 진입 메서드
        
        매개변수:
            index (int): 데이터 포인트의 인덱스
        반환값:
            데이터 포인트의 특성(x_data)과 레이블(y_target)로 이루어진 딕셔너리
        """
        row = self._target_df.iloc[index]

        context_vector = \
            self._vectorizer.vectorize(row.context, self._max_seq_length)
        target_index = self._vectorizer.cbow_vocab.lookup_token(row.target)

        return {'x_data': context_vector,
                'y_target': target_index}

 

2.2 본 코드에는 DataLoader를 감싸고 있는 제너레이터 함수가 추가되어있다.

def generate_batches(dataset, batch_size, shuffle=True,
                     drop_last=True, device="cpu"): 
    """
    파이토치 DataLoader를 감싸고 있는 제너레이터 함수.
    걱 텐서를 지정된 장치로 이동합니다.
    """
    dataloader = DataLoader(dataset=dataset, batch_size=batch_size,
                            shuffle=shuffle, drop_last=drop_last)

    for data_dict in dataloader:
        out_data_dict = {}
        for name, tensor in data_dict.items():
            out_data_dict[name] = data_dict[name].to(device)
        yield out_data_dict

 

3. Vectorizer class

• 어휘 사전을 생성하고 관리하는 클래스
• 문맥의 인덱스를 나타내는 정수 벡터를만들어서 반환한다.
• 문맥의 토큰 수가 최대 길이보다 작으면 0으로 채워지는 제로패딩을 수헹한다. 

vectorizer 전체코드는 더보기 클릭

class CBOWVectorizer(object):
    """ 어휘 사전을 생성하고 관리합니다 """
    def __init__(self, cbow_vocab):
        """
        매개변수:
            cbow_vocab (Vocabulary): 단어를 정수에 매핑합니다
        """
        self.cbow_vocab = cbow_vocab

    def vectorize(self, context, vector_length=-1):
        """
        매개변수:
            context (str): 공백으로 나누어진 단어 문자열
            vector_length (int): 인덱스 벡터의 길이 매개변수
        """

        indices = [self.cbow_vocab.lookup_token(token) for token in context.split(' ')]
        if vector_length < 0:
            vector_length = len(indices)

        out_vector = np.zeros(vector_length, dtype=np.int64)
        out_vector[:len(indices)] = indices
        out_vector[len(indices):] = self.cbow_vocab.mask_index

        return out_vector
    
    @classmethod
    def from_dataframe(cls, cbow_df):
        """데이터셋 데이터프레임에서 Vectorizer 객체를 만듭니다
        
        매개변수::
            cbow_df (pandas.DataFrame): 타깃 데이터셋
        반환값:
            CBOWVectorizer 객체
        """
        cbow_vocab = Vocabulary()
        for index, row in cbow_df.iterrows():
            for token in row.context.split(' '):
                cbow_vocab.add_token(token)
            cbow_vocab.add_token(row.target)
            
        return cls(cbow_vocab)

    @classmethod
    def from_serializable(cls, contents):
        cbow_vocab = \
            Vocabulary.from_serializable(contents['cbow_vocab'])
        return cls(cbow_vocab=cbow_vocab)

    def to_serializable(self):
        return {'cbow_vocab': self.cbow_vocab.to_serializable()}

3.1 Vectorizer 내부 메서드 살펴보기

▶ Vectorizer 생성자 메서드 __init__(self, cbow_vocab)

• 단어를 정수에 매핑한 cbow vocab을 반환한다.

    def __init__(self, cbow_vocab):
        """
        매개변수:
            cbow_vocab (Vocabulary): 단어를 정수에 매핑합니다
        """
        self.cbow_vocab = cbow_vocab

 

▶ vectorizer(self, context, vector_length = 1)

• 문자열과 인덱스 벡터의 길이를 매개변수로 받는다

    def vectorize(self, context, vector_length=-1):
        """
        매개변수:
            context (str): 공백으로 나누어진 단어 문자열
            vector_length (int): 인덱스 벡터의 길이 매개변수
        """

        indices = [self.cbow_vocab.lookup_token(token) for token in context.split(' ')]
        if vector_length < 0:
            vector_length = len(indices)

        # 일단 벡터 길이만큼의 zero 리스트를 생성해준다. (제로패딩)
        out_vector = np.zeros(vector_length, dtype=np.int64)
        out_vector[:len(indices)] = indices
        out_vector[len(indices):] = self.cbow_vocab.mask_index

        return out_vector

 

▶ from_dataframe(cls, cbow_df)

• 데이터프레임의 형태로 되어있는 cbow df를 매개변수로 받아온다.
• vocab이라는 vocabulary 객체를 생성하고, 해당 vocab으로 정수를 매핑

    @classmethod
    def from_dataframe(cls, cbow_df):
        """데이터셋 데이터프레임에서 Vectorizer 객체를 만듭니다
        
        매개변수::
            cbow_df (pandas.DataFrame): 타깃 데이터셋
        반환값:
            CBOWVectorizer 객체
        """
        cbow_vocab = Vocabulary()
        for index, row in cbow_df.iterrows():
            for token in row.context.split(' '):
                # add_tocken(aa) : aa에 상응하는 인덱스를 반환해준다.
                cbow_vocab.add_token(token)
            cbow_vocab.add_token(row.target)
          
        # 정
        return cls(cbow_vocab)

 

▶ from_serializable(cls, contents)
▶ to_serializable(self)

• from
  • vocab을 받아와서 정수가 매핑된 vocab을 얻는다.
  • 반환값은 cls이므로 결국 vectorizer의 객체
• to
  • 직렬화된 vocab으로 만들어주는 역할

    @classmethod
    def from_serializable(cls, contents):
        cbow_vocab = \
            Vocabulary.from_serializable(contents['cbow_vocab'])
        return cls(cbow_vocab=cbow_vocab)

    def to_serializable(self):
        return {'cbow_vocab': self.cbow_vocab.to_serializable()}

 

4. Vocabulary class

매핑을 위해 텍스트를 처리하고 어휘 사전을 만드는 클래스이다. 이전 포스팅의 vocabulary class와 구성과 함수가 동일하다. 따라서 (더보기클릭) 전체코드만 첨부하고 간단한 설명만 덧붙이겠다.

class Vocabulary(object):
    """ 매핑을 위해 텍스트를 처리하고 어휘 사전을 만드는 클래스 """

    def __init__(self, token_to_idx=None, mask_token="<MASK>", add_unk=True, unk_token="<UNK>"):
        """
        매개변수:
            token_to_idx (dict): 기존 토큰-인덱스 매핑 딕셔너리
            mask_token (str): Vocabulary에 추가할 MASK 토큰.
                모델 파라미터를 업데이트하는데 사용하지 않는 위치를 나타냅니다.
            add_unk (bool): UNK 토큰을 추가할지 지정하는 플래그
            unk_token (str): Vocabulary에 추가할 UNK 토큰
        """

        if token_to_idx is None:
            token_to_idx = {}
        self._token_to_idx = token_to_idx

        self._idx_to_token = {idx: token 
                              for token, idx in self._token_to_idx.items()}
        
        self._add_unk = add_unk
        self._unk_token = unk_token
        self._mask_token = mask_token
        
        self.mask_index = self.add_token(self._mask_token)
        self.unk_index = -1
        if add_unk:
            self.unk_index = self.add_token(unk_token) 
        
    def to_serializable(self):
        """ 직렬화할 수 있는 딕셔너리를 반환합니다 """
        return {'token_to_idx': self._token_to_idx, 
                'add_unk': self._add_unk, 
                'unk_token': self._unk_token, 
                'mask_token': self._mask_token}

    @classmethod
    def from_serializable(cls, contents):
        """ 직렬화된 딕셔너리에서 Vocabulary 객체를 만듭니다 """
        return cls(**contents)

    def add_token(self, token):
        """ 토큰을 기반으로 매핑 딕셔너리를 업데이트합니다

        매개변수:
            token (str): Vocabulary에 추가할 토큰
        반환값:
            index (int): 토큰에 상응하는 정수
        """
        if token in self._token_to_idx:
            index = self._token_to_idx[token]
        else:
            index = len(self._token_to_idx)
            self._token_to_idx[token] = index
            self._idx_to_token[index] = token
        return index
            
    def add_many(self, tokens):
        """ 토큰 리스트를 Vocabulary에 추가합니다.
        
        매개변수:
            tokens (list): 문자열 토큰 리스트
        반환값:
            indices (list): 토큰 리스트에 상응되는 인덱스 리스트
        """
        return [self.add_token(token) for token in tokens]

    def lookup_token(self, token):
        """ 토큰에 대응하는 인덱스를 추출합니다.
        토큰이 없으면 UNK 인덱스를 반환합니다.
        
        매개변수:
            token (str): 찾을 토큰 
        반환값:
            index (int): 토큰에 해당하는 인덱스
        노트:
            UNK 토큰을 사용하려면 (Vocabulary에 추가하기 위해)
            `unk_index`가 0보다 커야 합니다.
        """
        if self.unk_index >= 0:
            return self._token_to_idx.get(token, self.unk_index)
        else:
            return self._token_to_idx[token]

    def lookup_index(self, index):
        """ 인덱스에 해당하는 토큰을 반환합니다.
        
        매개변수: 
            index (int): 찾을 인덱스
        반환값:
            token (str): 인텍스에 해당하는 토큰
        에러:
            KeyError: 인덱스가 Vocabulary에 없을 때 발생합니다.
        """
        if index not in self._idx_to_token:
            raise KeyError("the index (%d) is not in the Vocabulary" % index)
        return self._idx_to_token[index]

    def __str__(self):
        return "<Vocabulary(size=%d)>" % len(self)

    def __len__(self):
        return len(self._token_to_idx)

▷ Vocabulary 클래스에 등장하는 함수 정리

1. __init__(self, token_to_idx=None, add_unk=True, unk_token="<UNK>"
   1. 매개변수 설명
      • token_to_idx (dict) : 기존 토큰-인덱스 매핑 딕셔너리
        • mask_token(str) : vocabulary에 추가할 MASK토큰 (모델 파라미터를 업데이트 하는데 사용하지 않는 위치를 나타낸다.)
      • add_unk (bool) : UNK 토큰을 추가할지 지정하는 플래그
      • unk_token (str) : Vocabulary에 추가할  UNK 토큰
2. to_serializable(self)
   1. 직렬화 할 수 있는 딕셔너리를 반환
      • {'token_to_idx': self._token_to_idx, 'add_unk': self._add_unk, 'unk_token': self._unk_token, 'mask_token': self._mask_token} 형태
3. @classmethod from_serializable(cls, contents)
   1. 직렬화된 딕셔너리에서 vocabulary 객체를 생성
4. add_token(self, token)
   1. 새로운 토큰을 추가하기 위한 함수
   2. 토큰을 기반으로 매핑 딕셔너리를 업데이트해준다
   3. 매개변수 token 이 Vocabulary에 추가할 토큰이 된다.
   4. return index : 토큰에 상응하는 인덱스가 반환값으로 출력
5.  add_many(self, tokens)
   1. 토큰 리스트를 vocabulary에 추가
   2. tokens 는 문자열 list
   3. 반환값도 tokens 에 상응하는 인덱스값
6. lookup_token(self, token)
   1. 토큰에 대응하는 인덱스를 추출하는 메서드
   2. 매개변수 token 이 찾을 토큰이고
   3. 반환값은 token이 갖는 인덱스값
7. lookup_index(self, index)
   1. 인덱스에 대응하는 토큰을 찾는 메서드
   2. 매개변수 index가 찾을 인덱스
   3. 반환값은 index 에 해당하는 토큰

 

 

<NEXT> 다음 글에서는 해당 class를 활용하여 모델을 생성하고, 훈련하는 과정에 대해서 포스팅 하겠다.

https://didu-story.tistory.com/102

[NLP] Pytorch를 활용하여 CBOW 임베딩 학습하기 (2)모델 훈련