[NLP] 레스토랑 리뷰 감성 분류하기 (2) (feat.파이토치로 배우는 자연어 처리) - 데이터 처리를 위한 클래스 살펴보기

-- 본 포스팅은 파이토치로 배우는 자연어 처리 (한빛미디어) 책을 참고해서 작성된 글입니다.
-- 소스코드 ) https://github.com/rickiepark/nlp-with-pytorch

rickiepark/nlp-with-pytorch

 

▶ 레스토랑 리뷰 감성 분류하기

아래 포스팅에서 어떻게 전처리된 데이터를 사용하게 됐는지 미리 학습하면 좋을 것이다. 하지만 해당 코드에서는 '전처리 과정'이 생략된 '전처리 되어진 데이터'를 활용하고 있다는 것만 알아두자.

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

[NLP] 레스토랑 리뷰 감성 분류하기 (1) (feat.파이토치로 배우는 자연어 처리)

 

 

1. 파이토치 데이터셋 이해하기

해당 프로젝트는 pytorch 프레임워크를 기반으로 진행된다. 그리고 클래스 객체를 활용해서 주요한 파이프라인을 수행하게 된다. 파이썬의 클래스객체에 대한 이해가 부족하다면 아래 포스팅을 참고하고 이해하고 오자. 또한 파이토치는 Dataset, DataLoader 를 활용하여 데이터의 형태를 변환시켜주는데, 이에대한 것도 아래 포스팅을 참고하면 이해가 더 쉬울 것이다.

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

[Pytorch] 파이토치의 Custom dataset과 DataLoader 이해하기

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

[파이썬] 클래스 객체

 

1.1 Review Dataset

• ReviewDataset 클래스는 데이터셋이 최소한으로 정제되고 3개로 나뉘었다고 가정한다.
• 특히 해당 데이터셋은 공백을 기준으로 나눠서 토큰 리스트를 얻을 수 있다고 가정한다.
• 샘플이 훈련, 검증, 테스트 중 어느 세트에 있는지 표시되었다고 가정한다.
  
  • 해당 데이터셋의 전처리 과정은 아래 링크 참고
  • https://didu-story.tistory.com/83

class ReviewDataset(Dataset):
    
    #클래스 인스턴스 생성시 초기화 하면서 실행되는 부분
    # self 란? 인스턴스(클래스에 의해 만들어진 객체) 자기자신을 의미,
    # self 가 있는 것이 인스턴스 변수 
    def __init__(self, review_df, vectorizer):
        """
        매개변수:
            review_df (pandas.DataFrame): 데이터셋
            vectorizer (ReviewVectorizer): ReviewVectorizer 객체
        """
        self.review_df = review_df
        self._vectorizer = vectorizer

        self.train_df = self.review_df[self.review_df.split=='train']
        self.train_size = len(self.train_df)

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

        self.test_df = self.review_df[self.review_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')

    # 클래스 메소드 (데코레이터 사용) = 클래스 변수를 컨트롤 할 때 사용된다.
    # cls 인자를 받음. cls? ReviewDataset 클래스를 뜻함
    @classmethod
    def load_dataset_and_make_vectorizer(cls, review_csv):
        # ReviewVectorizer객체 = 아래 나옴 (어휘사전을 생성하고 관리하는 객체)
        """ 데이터셋을 로드하고 새로운 ReviewVectorizer 객체를 만듭니다 
        
        매개변수:
            review_csv (str): 데이터셋의 위치
        반환값:
            ReviewDataset의 인스턴스
        """
        review_df = pd.read_csv(review_csv)  # 아래에서 review_csv를 통해 정제된 데이터를 가져올거야
        train_review_df = review_df[review_df.split=='train']
        return cls(review_df, ReviewVectorizer.from_dataframe(train_review_df))
    
    @classmethod
    def load_dataset_and_load_vectorizer(cls, review_csv, vectorizer_filepath):
        """ 데이터셋을 로드하고 새로운 ReviewVectorizer 객체를 만듭니다.
        캐시된 ReviewVectorizer 객체를 재사용할 때 사용합니다.
        
        매개변수:
            review_csv (str): 데이터셋의 위치
            vectorizer_filepath (str): ReviewVectorizer 객체의 저장 위치
        반환값:
            ReviewDataset의 인스턴스
        """
        review_df = pd.read_csv(review_csv)
        vectorizer = cls.load_vectorizer_only(vectorizer_filepath)
        return cls(review_df, vectorizer)

    @staticmethod
    def load_vectorizer_only(vectorizer_filepath):
        """ 파일에서 ReviewVectorizer 객체를 로드하는 정적 메서드
        
        매개변수:
            vectorizer_filepath (str): 직렬화된 ReviewVectorizer 객체의 위치
        반환값:
            ReviewVectorizer의 인스턴스
        """
        with open(vectorizer_filepath) as fp:
            return ReviewVectorizer.from_serializable(json.load(fp))

    def save_vectorizer(self, vectorizer_filepath):
        """ ReviewVectorizer 객체를 json 형태로 디스크에 저장합니다
        
        매개변수:
            vectorizer_filepath (str): ReviewVectorizer 객체의 저장 위치
        """
        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"):
        """ 데이터프레임에 있는 열을 사용해 분할 세트를 선택합니다 
        
        매개변수:
            split (str): "train", "val", "test" 중 하나
        """
        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]

        review_vector = \
            self._vectorizer.vectorize(row.review)

        rating_index = \
            self._vectorizer.rating_vocab.lookup_token(row.rating)

        return {'x_data': review_vector,
                'y_target': rating_index}

    def get_num_batches(self, batch_size):
        """ 배치 크기가 주어지면 데이터셋으로 만들 수 있는 배치 개수를 반환합니다
        
        매개변수:
            batch_size (int)
        반환값:
            배치 개수
        """
        return len(self) // batch_size

• 파이토치에서 새로운 데이터셋을 사용하려면 먼저 Dataset 클래스를 상속하여 __getitem()__, __len__() 메서드를 구현해야한다.
  • from torch.utils.data import Dataset, DataLoader
• 해당 클래스 안에서는 다양한 파이토치 유틸리티를 사용하는데, DataLoader / ReviewVectorizer 과 같은 클래스는 아래에 나온다. (클래스들은 서로 크게 의존한다.)
  • ReviewVectorizer => 리뷰텍스트를 수치로 변환하는 클래스
  • DataLoader => 데이터셋에서 샘플링하고 모아서 미니배치를 만드는 클래스
    • 데이터 로더와 미니배치? https://wikidocs.net/55580

▷ 여기서 잠깐, Dataset 클래스를 상속한다는 뜻이 무엇일까?

• torch.utils.data.Dataset 은 데이터셋을 나타내는 '추상 클래스'이다.
• 우리만의 데이터셋은 Dataset에 상속하고, 아래와 같이 오버라이드 해야한다.
  • len(dataset)에서 호출되는 __len__은 데이터셋의 크기를 리턴한다.
  • dataset[i]에서 호출되는 __getitem__은 i번째 샘플을 찾는데 사용된다.
• 즉, __init__을 통해 데이터를 처리해서 가져오지만, __getitem__을 이용해서 데이터를 하나씩 판독한다.
• 그리고 최종 리턴값은{'x_data': review_vector, 'y_target': rating_index} 형태의 사전 형태를 가진다.

 

▷ ReviewDataset 커스텀 데이터셋에 등장하는 함수 정리

1. __init__(self, review_df, Vectorizer)
   1. 데이터셋 (review_df)
   2. 벡터화해주는 객체(vectorizer)
   3. train_df / train_size / val_df / val_size / test_df / test_size 변수를 정의
2. @classmethod load_dataset_and_make_vectorizer(cls, review_csv) 
   1. 데이터셋을 로드하고 새로운 ReviewVectorizer 객체를 만들어주는 함수
   2. review_csv라는 데이터셋의 위치를 매개변수로 받는다
   3. ReviewDataset(reveiw_df, ReviewVectorizer.from_dataset(train_review_df) 한 결과값을 반환
      
      • ReviewVectorizer.from_dataset 는 데이터셋 데이터프레임에서 Vectorizer 객체를 만드는 메서드
        반환값이 ReviewVectorizer 객체이다.
3. @staticmethod load_vectorizer_only(vetorizer_filepath)
   1. 파일에서 ReviewVectorizer 객체를 로드하는 정적 메서드
   2. ReviewVectorizer.from_serializable(json.load(fp)) 를 반환한다. 
      
      • ReviewVectorizer.from_serializable 는 직렬화된 딕셔너리(json.load(fp))에서 ReviewVectorizer 객체를 만드는 메서드
4. save_vectorizer(self, vectorizer_filepath)
   1. ReviewVectorizer 객체를 json형태로 디스크에 저장하는 메서드
5. get_vectorizer(self)
   1. 벡터 변환 객체를 반환하는 메서드self._vectorizer 값을 반환
6. set_split(self, split="train")
   1. 데이터 프레임에 있는 열을 사용하여 분할 세트를 선택 
      "train", "test", "val" 중 하나
7. __len__(self)
8. __getitem(self, index)
   1. {"x_data" : review_vector, "y_target" : rating_index} 로 이루어진 dic형태로 반환
9. get_num_batches(self, batch_size)
   1. 배치 크기가 주어지면 데이터셋으로 만들 수있는 배치 개수를 반환

 

1.2 Vocabulary, Vetorizer, DataLoader 클래스

• 해당 예제는 위 세개의 클래스를 활용하여 중요한 파이프라인을 수행한다.
• 텍스트의 입력을 벡터의 미니배치로 바꿔주기 위해 해당 클래스들을 사용한다.
  • 이 세개의 클래스는 각 토큰을 정수에 매핑하고, 이 매핑을 각 데이터포인트에 적용하여 벡터 형태로 변환해준다. 그 다음 벡터로 변환한 데이터 포인트를 모델을 위해 미니배치로 모은다.
• 전처리 된 데이터(텍스트)를 사용한다. (즉 데이터포인트는 토큰화된 집합이다.

 

1.2.1 Vocabulary 클래스

• 머신러닝 파이프라인에 필요한 토큰과 정수 매핑을 관리하는 클래스
• 토큰을 정수로 매핑하는 클래스  (텍스트의 배치를 미니배치로 바꾸는 과정의 첫 단계)
• 토큰과 정수 사이를 1:1 매핑하는 방법 (반대로 매핑하는 경우까지, 총 딕셔너리 두개 필요)
• 두 딕셔너리를 Vocabulary 클래스에 캡슐화 한 것
• 훈련 데이터셋에 없는 단어는 UNK (Unknown) 으로 처리
  • 자주 등장하지 않는 토큰들을 제한해줌 => 이런 토큰들이 UNK으로 처리되는 것

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

    def __init__(self, token_to_idx=None, add_unk=True, unk_token="<UNK>"):
        """
        매개변수:
            token_to_idx (dict): 기존 토큰-인덱스 매핑 딕셔너리
            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.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}

    @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("Vocabulary에 인덱스(%d)가 없습니다." % 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) : 기존 토큰-인덱스 매핑 딕셔너리
      • 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} 형태
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 에 해당하는 토큰

 

1.2.2 Vectorizer 클래스

• 텍스트를 수치 벡터로 변환하는 클래스이자, 어휘 사전을 생성하고 관리하는 클래스
• 텍스트 데이터를 벡터의 미니배치로 바꾸는 두번째 단계
• 입력 데이터 포인트의 토큰을 순회하면서 각 토큰을 정수로 바꿔주는 것
• 해당 클래스의 결과는 '벡터'
• 항상 길이가 일정한 벡터 출력

class ReviewVectorizer(object):
    """ 어휘 사전을 생성하고 관리합니다 """
    def __init__(self, review_vocab, rating_vocab):
        """
        매개변수:
            review_vocab (Vocabulary): 단어를 정수에 매핑하는 Vocabulary
            rating_vocab (Vocabulary): 클래스 레이블을 정수에 매핑하는 Vocabulary
        """
        self.review_vocab = review_vocab
        self.rating_vocab = rating_vocab

    # vectorize 매서드는 해당 클래스의 핵심적인 기능을 캡슐화
    # 매개 변수로 리뷰 문자열을 받음 (review) 이 리뷰의 벡터 표현을 반환
    # 리뷰 단어에 해당하는 위치가 1이 되도록. 
    def vectorize(self, review):
        """ 리뷰에 대한 웟-핫 벡터를 만듭니다
        
        매개변수:
            review (str): 리뷰
        반환값:
            one_hot (np.ndarray): 원-핫 벡터
        """
        one_hot = np.zeros(len(self.review_vocab), dtype=np.float32)
        
        for token in review.split(" "):
            if token not in string.punctuation:
                one_hot[self.review_vocab.lookup_token(token)] = 1

        return one_hot

    # 데코레이터를 사용하여 from_dataframe()이 Vectorizer 클래스를 초기화하는 진입점임을 나타냄
    # 판다스 데이터프레임을 순회하면서 아래 두 가지 작업을 수행
    # 1. 데이터셋에 있는 모든 토큰의 빈도수 카운트
    # 2. 키워드 매개변수 cutoff에 지정한 수보다 빈도가 높은 토큰만 사용하는 vocabulary 객체 생성
    #     최소한 cutoff 횟수보다 많이 등장하는 단어를 모두 찾아 vocabulary 객체에 추가

    @classmethod
    def from_dataframe(cls, review_df, cutoff=25):
        """ 데이터셋 데이터프레임에서 Vectorizer 객체를 만듭니다
        
        매개변수:
            review_df (pandas.DataFrame): 리뷰 데이터셋
            cutoff (int): 빈도 기반 필터링 설정값
        반환값:
            ReviewVectorizer 객체
        """
        review_vocab = Vocabulary(add_unk=True)
        rating_vocab = Vocabulary(add_unk=False)
        
        # 점수를 추가합니다
        for rating in sorted(set(review_df.rating)):
            rating_vocab.add_token(rating)

        # count > cutoff인 단어를 추가합니다
        word_counts = Counter()
        for review in review_df.review:
            for word in review.split(" "):
                if word not in string.punctuation:
                    word_counts[word] += 1
               
        for word, count in word_counts.items():
            if count > cutoff:
                review_vocab.add_token(word)

        return cls(review_vocab, rating_vocab)

    @classmethod
    def from_serializable(cls, contents):
        """ 직렬화된 딕셔너리에서 ReviewVectorizer 객체를 만듭니다
        
        매개변수:
            contents (dict): 직렬화된 딕셔너리
        반환값:
            ReviewVectorizer 클래스 객체
        """
        review_vocab = Vocabulary.from_serializable(contents['review_vocab'])
        rating_vocab =  Vocabulary.from_serializable(contents['rating_vocab'])

        return cls(review_vocab=review_vocab, rating_vocab=rating_vocab)

    def to_serializable(self):
        """ 캐싱을 위해 직렬화된 딕셔너리를 만듭니다
        
        반환값:
            contents (dict): 직렬화된 딕셔너리
        """
        return {'review_vocab': self.review_vocab.to_serializable(),
                'rating_vocab': self.rating_vocab.to_serializable()}

• 해당 vectorize 메서드를 보면 원핫백터로 해당 단어가 해당하는 위치에 1이 되는 벡터를 반환한다.
• 하지만 이런 표현 방법은 몇가지 제약이 존재한다.
  
  • 희소한 배열이라는 점 ( 한 리뷰의 고유 단어 수는 항상 vocabulary 전체 단어수 보다 훨씬 작다.)
  • 리뷰에 등장하는 단어 순서를 무시한 방법이다 ( BoW 방식)

 

1.2.3 DataLoader

• 벡터로 변환하는 미니배치 파이프라인의 마지막 단계는 벡터로 변환한 데이터 포인트 모으기 
• 파이토치 내장 클래스인 DataLoader는 신경망에 필수적인 미니배치로 모으는 작업을 수행해줌
• DataLoader 클래스는 파이토치 DataSet(이 예제에서는 ReviewDataset, 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

 

 

<NEXT> https://didu-story.tistory.com/87 

[NLP] 레스토랑 리뷰 감성 분류하기 (3) (feat.파이토치로 배우는 자연어 처리) - 훈련 및 평가, 추론,