PyTorch 는 TorchText 를 사용 하여 텍스트 분 류 를 진행 합 니 다.

그림 과 글 이 모두 훌륭 한 튜 토리 얼 을 보 려 면 이동 하 십시오.http://studyai.com/pytorch-1.4/beginner/text_sentiment_ngrams_tutorial.html
이 튜 토리 얼 은 torchtext 에서 텍스트 분류 데이터 세트 를 사용 하 는 방법 을 보 여 줍 니 다.

- AG_NEWS,
- SogouNews,
- DBpedia,
- YelpReviewPolarity,
- YelpReviewFull,
- YahooAnswers,
- AmazonReviewPolarity,
- AmazonReviewFull

이 예제 에 서 는 텍스트 데 이 터 를 분류 하 는 감독 학습 알고리즘 을 어떻게 사용 하 는 지 보 여 줍 니 다.
ngrams 로 데 이 터 를 불 러 옵 니 다.
ngrams 특징 패키지 (A bag of ngrams feature) 는 로 컬 어순 에 대한 일부 정 보 를 캡 처 하 는 데 사 용 됩 니 다.실제 응용 에 서 는 한 단어 (word) 만 사용 하 는 것 보다 두 글자 (bi - gram) 나 세 글자 (tri - gram) 를 어구 로 사용 하 는 것 이 더 유익 하 다.예 를 들 면:

"load data with ngrams"
Bi-grams results: "load data", "data with", "with ngrams"
Tri-grams results: "load data with", "data with ngrams"

TextClassification Dataset 은 ngrams 방법 을 지원 합 니 다.ngrams 를 2 로 설정 하면 데이터 가 집 중 된 예제 텍스트 는 한 글자 에 bi - grams 문자열 을 추가 하 는 목록 입 니 다.

import torch
import torchtext
from torchtext.datasets import text_classification
NGRAMS = 2
import os
if not os.path.isdir('./.data'):
    os.mkdir('./.data')
train_dataset, test_dataset = text_classification.DATASETS['AG_NEWS'](
    root='./.data', ngrams=NGRAMS, vocab=None)
BATCH_SIZE = 16
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

정의 모델
모형 은 Embeddingbag 층 과 선형 층 으로 구성 되 어 있다 (아래 그림 참조).N. Embeddingbag 는 embeddings 의 'bag' 의 평균 치 를 계산한다.이곳 의 텍스트 항목 은 길이 가 다르다.N. Embeddingbag 는 텍스트 길이 가 오프셋 으로 저장 되 어 있 기 때문에 채 울 필요 가 없습니다.
또한, N. Embeddingbag 온라인 동적 으로 embeddings 의 평균 값 이 누적 되 었 기 때문에 N. Embeddingbag 는 장 량 서열 을 처리 하 는 성능 과 메모리 효율 을 높 일 수 있 습 니 다.images/text_sentiment_ngrams_model.png

import torch.nn as nn
import torch.nn.functional as F
class TextSentiment(nn.Module):
    def __init__(self, vocab_size, embed_dim, num_class):
        super().__init__()
        self.embedding = nn.EmbeddingBag(vocab_size, embed_dim, sparse=True)
        self.fc = nn.Linear(embed_dim, num_class)
        self.init_weights()

    def init_weights(self):
        initrange = 0.5
        self.embedding.weight.data.uniform_(-initrange, initrange)
        self.fc.weight.data.uniform_(-initrange, initrange)
        self.fc.bias.data.zero_()

    def forward(self, text, offsets):
        embedded = self.embedding(text, offsets)
        return self.fc(embedded)

모델 초기 화
AG_뉴스 데이터 세트 는 네 개의 태그 가 있 기 때문에 클래스 의 수량 은 네 개 입 니 다.
1 : World 2 : Sports 3 : Business 4 : Sci/Tec
The vocab size is equal to the length of vocab (including single word and ngrams). The number of classes is equal to the number of labels, which is four in AG_NEWS case.

VOCAB_SIZE = len(train_dataset.get_vocab())
EMBED_DIM = 32
NUN_CLASS = len(train_dataset.get_labels())
model = TextSentiment(VOCAB_SIZE, EMBED_DIM, NUN_CLASS).to(device)

대량 데이터 생 성 에 사용 되 는 함수
텍스트 항목 의 길이 가 다 르 기 때문에 사용자 정의 함수 generate 를 사용 합 니 다.batch () 는 데이터 batch 와 오프셋 을 생 성 합 니 다.이 함 수 는 torch. utils. data. dataLoader 에 전 달 된 collatefn 。 collate_fn 의 입력 은 batchsize 크기 의 장 량 목록, collatefn 함수 가 그것들 을 mini - batch 로 포장 합 니 다.여기 주의 하 세 요. collate 확보 해 야 합 니 다.fn 은 모든 스 레 드 (worker) 가 이 기능 을 사용 할 수 있 도록 최상 위 정의 함수 로 밝 혀 졌 습 니 다.
원본 데이터 batch 입력 에 있 는 텍스트 항목 은 목록 으로 포장 되 어 있 으 며, N. Embeddingbag 의 입력 으로 하나의 장 량 으로 연결 되 어 있 습 니 다.오프셋 (offsets) 은 구분자 의 장 량 으로 텍스트 장 량 의 단일 시퀀스 의 시작 색인 을 표시 합 니 다.Label 은 단일 텍스트 항목 탭 을 저장 하 는 장 량 입 니 다.

def generate_batch(batch):
    label = torch.tensor([entry[0] for entry in batch])
    text = [entry[1] for entry in batch]
    offsets = [0] + [len(entry) for entry in text]
    # torch.Tensor.cumsum returns the cumulative sum
    # of elements in the dimension dim.
    # torch.Tensor([1.0, 2.0, 3.0]).cumsum(dim=0)

    offsets = torch.tensor(offsets[:-1]).cumsum(dim=0)
    text = torch.cat(text)
    return text, offsets, label

훈련 및 평가 모델 의 함수 정의
PyTorch 사용자 에 게 torch. utils. data. dataLoader 를 사용 하 는 것 을 권장 합 니 다. 데 이 터 를 쉽게 병렬 로 불 러 올 수 있 습 니 다.저 희 는 여기 서 DataLoader 를 사용 하여 AG 를 불 러 옵 니 다.뉴스 데이터 세트 를 모델 에 보 내 훈련 / 검증 을 한다.

from torch.utils.data import DataLoader

def train_func(sub_train_):

    #     
    train_loss = 0
    train_acc = 0
    data = DataLoader(sub_train_, batch_size=BATCH_SIZE, shuffle=True,
                      collate_fn=generate_batch)
    for i, (text, offsets, cls) in enumerate(data):
        optimizer.zero_grad()
        text, offsets, cls = text.to(device), offsets.to(device), cls.to(device)
        output = model(text, offsets)
        loss = criterion(output, cls)
        train_loss += loss.item()
        loss.backward()
        optimizer.step()
        train_acc += (output.argmax(1) == cls).sum().item()

    #      
    scheduler.step()

    return train_loss / len(sub_train_), train_acc / len(sub_train_)

def test(data_):
    loss = 0
    acc = 0
    data = DataLoader(data_, batch_size=BATCH_SIZE, collate_fn=generate_batch)
    for text, offsets, cls in data:
        text, offsets, cls = text.to(device), offsets.to(device), cls.to(device)
        with torch.no_grad():
            output = model(text, offsets)
            loss = criterion(output, cls)
            loss += loss.item()
            acc += (output.argmax(1) == cls).sum().item()

    return loss / len(data_), acc / len(data_)

데이터 세트 구분 및 실행 모델
원시 AG 때문에뉴스 에 올 바른 데이터 세트 가 없습니다. 저 희 는 훈련 데이터 세트 를 0.95 (train) 와 0.05 (valid) 분할 비 를 가 진 train / valid 세트 로 나 누 었 습 니 다.여기 서 PyTorch 핵심 라 이브 러 리 에 있 는 torch. utils. data. dataset. random 을 사용 합 니 다.split 함수.
CrossEntropy Loss 준칙 은 N. LogSoftmax () 와 N. NLLLLoss () 를 한 종류 에 조합 했다.그것 은 C 류 분류 문 제 를 훈련 할 때 매우 유용 하 다.SGD 는 유 틸 리 티 로 서 랜 덤 경사도 하강 법 을 실현 했다.초기 학습 율 을 4.0 으로 설정 합 니 다.여기 서 StepLR 을 사용 하여 각 라운드 (epoch) 의 학습 율 을 조정 합 니 다.

import time
from torch.utils.data.dataset import random_split
N_EPOCHS = 5
min_valid_loss = float('inf')

criterion = torch.nn.CrossEntropyLoss().to(device)
optimizer = torch.optim.SGD(model.parameters(), lr=4.0)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1, gamma=0.9)

train_len = int(len(train_dataset) * 0.95)
sub_train_, sub_valid_ = \
    random_split(train_dataset, [train_len, len(train_dataset) - train_len])

for epoch in range(N_EPOCHS):

    start_time = time.time()
    train_loss, train_acc = train_func(sub_train_)
    valid_loss, valid_acc = test(sub_valid_)

    secs = int(time.time() - start_time)
    mins = secs / 60
    secs = secs % 60

    print('Epoch: %d' %(epoch + 1), " | time in %d minutes, %d seconds" %(mins, secs))
    print(f'\tLoss: {train_loss:.4f}(train)\t|\tAcc: {train_acc * 100:.1f}%(train)')
    print(f'\tLoss: {valid_loss:.4f}(valid)\t|\tAcc: {valid_acc * 100:.1f}%(valid)')

GPU 에서 모델 을 실행 하고 다음 과 같은 정 보 를 얻 을 수 있 습 니 다.

Epoch: 1 | time in 0 minutes, 11 seconds

Loss: 0.0263(train)     |       Acc: 84.5%(train)
Loss: 0.0001(valid)     |       Acc: 89.0%(valid)

Epoch: 2 | time in 0 minutes, 10 seconds

Loss: 0.0119(train)     |       Acc: 93.6%(train)
Loss: 0.0000(valid)     |       Acc: 89.6%(valid)

Epoch: 3 | time in 0 minutes, 9 seconds

Loss: 0.0069(train)     |       Acc: 96.4%(train)
Loss: 0.0000(valid)     |       Acc: 90.5%(valid)

Epoch: 4 | time in 0 minutes, 11 seconds

Loss: 0.0038(train)     |       Acc: 98.2%(train)
Loss: 0.0000(valid)     |       Acc: 90.4%(valid)

Epoch: 5 | time in 0 minutes, 11 seconds

Loss: 0.0022(train)     |       Acc: 99.0%(train)
Loss: 0.0000(valid)     |       Acc: 91.0%(valid)

테스트 데이터 세트 평가 모델 사용

print('Checking the results of test dataset...')
test_loss, test_acc = test(test_dataset)
print(f'\tLoss: {test_loss:.4f}(test)\t|\tAcc: {test_acc * 100:.1f}%(test)')

테스트 데이터 세트 결 과 를 검사 합 니 다.

Loss: 0.0237(test)      |       Acc: 90.5%(test)

랜 덤 뉴스 에서 테스트 하 다.
지금까지 의 가장 좋 은 모델 을 사용 하여 골프 뉴스 를 테스트 하 다.태그 정 보 는 여기 서 제공 합 니 다.

import re
from torchtext.data.utils import ngrams_iterator
from torchtext.data.utils import get_tokenizer

ag_news_label = {1 : "World",
                 2 : "Sports",
                 3 : "Business",
                 4 : "Sci/Tec"}

def predict(text, model, vocab, ngrams):
    tokenizer = get_tokenizer("basic_english")
    with torch.no_grad():
        text = torch.tensor([vocab[token]
                            for token in ngrams_iterator(tokenizer(text), ngrams)])
        output = model(text, torch.tensor([0]))
        return output.argmax(1).item() + 1

ex_text_str = "MEMPHIS, Tenn. – Four days ago, Jon Rahm was \
    enduring the season’s worst weather conditions on Sunday at The \
    Open on his way to a closing 75 at Royal Portrush, which \
    considering the wind and the rain was a respectable showing. \
    Thursday’s first round at the WGC-FedEx St. Jude Invitational \
    was another story. With temperatures in the mid-80s and hardly any \
    wind, the Spaniard was 13 strokes better in a flawless round. \
    Thanks to his best putting performance on the PGA Tour, Rahm \
    finished with an 8-under 62 for a three-stroke lead, which \
    was even more impressive considering he’d never played the \
    front nine at TPC Southwind."

vocab = train_dataset.get_vocab()
model = model.to("cpu")

print("This is a %s news" %ag_news_label[predict(ex_text_str, model, vocab, 2)])

This is a Sports news