5-4 사전 훈련된 임베딩을 활용한 전이 학습

AG 뉴스 데이터셋

AG's corpus of news articles

AG is a collection of more than 1 million news articles. News articles have been gathered frommore than 2000 news sources by ComeToMyHead in more than 1 year of activity. ComeToMyHead is an academic news search engine which has been running since July, 2004.

http://bit.ly/2SbWzpL

class NewsDataset(Dataset):
	@classmethod
	def load_dataset_and_make_vectorizer(cls, news_csv):
		# 데이터셋을 로드하고 처음부터 새로운 Vectorizer 만들기
		# news_csv(str): 데이터셋의 위치
		news_df = pd.read_csv(news_csv)
		train_news_df = news_df[news_df.split=='train']

		# NewsDataset의 인스턴스
		return cls(news_df, NewsVectorizer.form_dataframe(train_news_df))
	
	def __getitem__(self, index):
		# 파이토치 데이터셋의 주요 진입 메서드
		# index(int): 데이터 포인트의 인덱스
		row = self._target_df.iloc[index]

		title_vector = self._vectorizer.vectorize(row.title, self._max_seq_length)
		category_index = self._vectorizer.category_vocab.lookup_token(row.category)
		
		return {'x_data': title_vector, # 데이터 포인트의 특성
						'y_target': category_index} # 레이블

Vocabulary, Vectorizer, DataLoader

class NewsVectorizer(object):
	def vectorize(self, title, vector_length = -1):
	# title(str): 공백으로 나누어진 단어 문자열
	# vector_length(int): 인덱스 벡터의 길이 매개변수
		indices = [self.title_vocab.begin_seq_index]
		indices.extend(self.title_vocab.lookup_token(token)
										for token in title.split(" "))
		indices.append(self.title_vocab.end_seq_index)

		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.title_vocab.mask_index
		
		# 벡터로 변환된 제목 (넘파이 어레이)
		return out_vector

	@classmethod
	def from_dataframe(cls, news_df, cutoff=25):
  # 데이터셋 데이터프레임에서 Vectorizer 객체 만들기
	# news_df(pandas.DataFrame): 타깃 데이터셋
	# cutoff(int): Vocabulary에 포함할 빈도 임곗값
		category_vocab = Vocabulary()
		for category in sorted(set(news_df.category)):
			category_vocab.add_token(category)
		word_counts = Counter()
		for title in news_df.title:
			for token in title.split(" "):
				if token not in string.punctuation:
					word_counts[token] += 1
		
		title_vocab = SequenceVocabulary()
		for word, word_count in word_counts.items():
			if word_count >= cutoff:
				title_vocab.add_token(word)
		
		# NewsVectorizer 객체
		return cls(title_vocab, category_vocab)

NewsClassifier 모델

def load_glove_from_file(glove_filepath):
    # glove_filepath (str): 임베딩 파일 경로 
    word_to_index = {}
    embeddings = []
    with open(glove_filepath, "r") as fp:
        for index, line in enumerate(fp):
            line = line.split(" ") # each line: word num1 num2 ...
            word_to_index[line[0]] = index # word = line[0] 
            embedding_i = np.array([float(val) for val in line[1:]])
            embeddings.append(embedding_i)
		# word_to_index (dict), embeddings (numpy.ndarary)
    return word_to_index, np.stack(embeddings)


def make_embedding_matrix(glove_filepath, words):
    # 특정 단어 집합에 대한 임베딩 행렬 만들기
    # glove_filepath (str): 임베딩 파일 경로
    # words (list): 단어 리스트
    word_to_idx, glove_embeddings = load_glove_from_file(glove_filepath)
    embedding_size = glove_embeddings.shape[1]
    
    final_embeddings = np.zeros((len(words), embedding_size))

    for i, word in enumerate(words):
        if word in word_to_idx:
            final_embeddings[i, :] = glove_embeddings[word_to_idx[word]]
        else:
            embedding_i = torch.ones(1, embedding_size)
            torch.nn.init.xavier_uniform_(embedding_i)
            final_embeddings[i, :] = embedding_i
		# final_embeddings (numpu.ndarray): 임베딩 행렬
    return final_embeddings

class NewsClassifier(nn.Module):
    def __init__(self, embedding_size, num_embeddings, num_channels, 
                 hidden_dim, num_classes, dropout_p, 
                 pretrained_embeddings=None, padding_idx=0):
        """
        매개변수:
            embedding_size (int): 임베딩 벡터의 크기
            num_embeddings (int): 임베딩 벡터의 개수
            num_channels (int): 합성곱 커널 개수
            hidden_dim (int): 은닉 차원 크기
            num_classes (int): 클래스 개수
            dropout_p (float): 드롭아웃 확률
            pretrained_embeddings (numpy.array): 사전에 훈련된 단어 임베딩
                기본값은 None 
            padding_idx (int): 패딩 인덱스
        """
        super(NewsClassifier, self).__init__()

        if pretrained_embeddings is None:

            self.emb = nn.Embedding(embedding_dim=embedding_size,
                                    num_embeddings=num_embeddings,
                                    padding_idx=padding_idx)        
        else:
            pretrained_embeddings = torch.from_numpy(pretrained_embeddings).float()
            self.emb = nn.Embedding(embedding_dim=embedding_size,
                                    num_embeddings=num_embeddings,
                                    padding_idx=padding_idx,
                                    _weight=pretrained_embeddings)
        
            
        self.convnet = nn.Sequential(
            nn.Conv1d(in_channels=embedding_size, 
                   out_channels=num_channels, kernel_size=3),
            nn.ELU(),
            nn.Conv1d(in_channels=num_channels, out_channels=num_channels, 
                   kernel_size=3, stride=2),
            nn.ELU(),
            nn.Conv1d(in_channels=num_channels, out_channels=num_channels, 
                   kernel_size=3, stride=2),
            nn.ELU(),
            nn.Conv1d(in_channels=num_channels, out_channels=num_channels, 
                   kernel_size=3),
            nn.ELU()
        )

        self._dropout_p = dropout_p
        self.fc1 = nn.Linear(num_channels, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, num_classes)

    def forward(self, x_in, apply_softmax=False):
        """분류기의 정방향 계산
        
        매개변수:
            x_in (torch.Tensor): 입력 데이터 텐서 
                x_in.shape는 (batch, dataset._max_seq_length)입니다.
            apply_softmax (bool): 소프트맥스 활성화 함수를 위한 플래그
                크로스-엔트로피 손실을 사용하려면 False로 지정합니다
        반환값:
            결과 텐서. tensor.shape은 (batch, num_classes)입니다.
        """
        
        # 임베딩을 적용하고 특성과 채널 차원을 바꿉니다
        x_embedded = self.emb(x_in).permute(0, 2, 1)

        features = self.convnet(x_embedded)

        # 평균 값을 계산하여 부가적인 차원을 제거합니다
        remaining_size = features.size(dim=2)
        features = F.avg_pool1d(features, remaining_size).squeeze(dim=2)
        features = F.dropout(features, p=self._dropout_p)
        
        # MLP 분류기
        intermediate_vector = F.relu(F.dropout(self.fc1(features), p=self._dropout_p))
        prediction_vector = self.fc2(intermediate_vector)

        if apply_softmax:
            prediction_vector = F.softmax(prediction_vector, dim=1)

        return prediction_vector

모델 훈련

args = Namespace(
    # 날짜와 경로 정보
    news_csv="data/ag_news/news_with_splits.csv",
    vectorizer_file="vectorizer.json",
    model_state_file="model.pth",
    save_dir="model_storage/ch5/document_classification",
    # 모델 하이퍼파라미터
    glove_filepath='data/glove/glove.6B.100d.txt', 
    use_glove=False,
    embedding_size=100, 
    hidden_dim=100, 
    num_channels=100, 
    # 훈련 하이퍼파라미터
    seed=1337, 
    learning_rate=0.001, 
    dropout_p=0.1, 
    batch_size=128, 
    num_epochs=100, 
    early_stopping_criteria=5, 
    # 실행 옵션
    cuda=True, 
    catch_keyboard_interrupt=True, 
    reload_from_files=False,
    expand_filepaths_to_save_dir=True
)

모델 평가와 예측

테스트 데이터로 평가하기

새로운 뉴스 제목의 카테고리 예측하기

def predict_category(title, classifier, vectorizer, max_length):
    """뉴스 제목을 기반으로 카테고리를 예측합니다
    
    매개변수:
        title (str): 원시 제목 문자열
        classifier (NewsClassifier): 훈련된 분류기 객체
        vectorizer (NewsVectorizer): 해당 Vectorizer
        max_length (int): 최대 시퀀스 길이
    """
    title = preprocess_text(title)
    vectorized_title = \
        torch.tensor(vectorizer.vectorize(title, vector_length=max_length))
    result = classifier(vectorized_title.unsqueeze(0), apply_softmax=True)
    probability_values, indices = result.max(dim=1)
    predicted_category = vectorizer.category_vocab.lookup_index(indices.item())

    return {'category': predicted_category, 
            'probability': probability_values.item()}