D2L - 16.4. Natural Language Inference and the Dataset

16.4. Natural Language Inference and the Dataset — Dive into Deep Learning 1.0.3 documentation (d2l.ai)

16.4. Natural Language Inference and the Dataset — Dive into Deep Learning 1.0.3 documentation

16.4. Natural Language Inference and the Dataset

 

In Section 16.1, we discussed the problem of sentiment analysis. This task aims to classify a single text sequence into predefined categories, such as a set of sentiment polarities. However, when there is a need to decide whether one sentence can be inferred form another, or eliminate redundancy by identifying sentences that are semantically equivalent, knowing how to classify one text sequence is insufficient. Instead, we need to be able to reason over pairs of text sequences.

 

섹션 16.1에서 우리는 감정 분석의 문제를 논의했습니다. 이 작업의 목표는 단일 텍스트 시퀀스를 감정 극성 세트 set of sentiment polarities와 같은 사전 정의된 카테고리로 분류하는 것입니다. 그러나 한 문장이 다른 문장에서 추론될 수 있는지 여부를 결정하거나 의미상 동일한 문장을 식별하여 중복을 제거해야 하는 경우 하나의 텍스트 시퀀스를 분류하는 방법을 아는 것만으로는 충분하지 않습니다. 대신, 텍스트 시퀀스 쌍을 추론할 수 있어야 합니다.

 

16.4.1. Natural Language Inference

Natural language inference studies whether a hypothesis can be inferred from a premise, where both are a text sequence. In other words, natural language inference determines the logical relationship between a pair of text sequences. Such relationships usually fall into three types:

 

자연어 추론은 둘 다 텍스트 시퀀스인 전제로부터 가설을 추론할 수 있는지 여부를 연구합니다. 즉, 자연어 추론은 한 쌍의 텍스트 시퀀스 간의 논리적 관계를 결정합니다. 이러한 관계는 일반적으로 세 가지 유형으로 나뉩니다.

 

• Entailment: the hypothesis can be inferred from the premise.
  
  수반: 전제로부터 가설을 추론할 수 있습니다.
  
  
• Contradiction: the negation of the hypothesis can be inferred from the premise.
  
  모순: 가설의 부정은 전제로부터 추론될 수 있습니다.
  
  
• Neutral: all the other cases.
  
  중립: 다른 모든 경우.

 

Natural language inference is also known as the recognizing textual entailment task. For example, the following pair will be labeled as entailment because “showing affection” in the hypothesis can be inferred from “hugging one another” in the premise.

 

자연어 추론은 텍스트 수반 작업 인식으로도 알려져 있습니다. 예를 들어, 가설의 "애정 표시"가 전제의 "서로 포옹"에서 추론될 수 있기 때문에 다음 쌍은 수반으로 분류됩니다.

 

Premise (전제): Two women are hugging each other.

Hypothesis (가설): Two women are showing affection.

 

The following is an example of contradiction as “running the coding example” indicates “not sleeping” rather than “sleeping”.

 

다음은 "코딩 예제를 실행하는 것"이 "자고 있음"이 아닌 "자지 않음"을 의미하므로 모순의 예입니다.

 

Premise: A man is running the coding example from Dive into Deep Learning.

Hypothesis: The man is sleeping.

 

The third example shows a neutrality relationship because neither “famous” nor “not famous” can be inferred from the fact that “are performing for us”.

 

세 번째 예는 '우리를 위해 공연하고 있다'는 사실에서 '유명하다'도 '유명하지 않다'도 추론할 수 없기 때문에 중립 관계를 보여준다.

 

Premise: The musicians are performing for us.

Hypothesis: The musicians are famous.

 

Natural language inference has been a central topic for understanding natural language. It enjoys wide applications ranging from information retrieval to open-domain question answering. To study this problem, we will begin by investigating a popular natural language inference benchmark dataset.

 

자연어 추론은 자연어를 이해하기 위한 핵심 주제였습니다. 정보 검색부터 오픈 도메인 질문 응답까지 폭넓게 응용됩니다. 이 문제를 연구하기 위해 먼저 인기 있는 자연어 추론 벤치마크 데이터 세트를 조사하겠습니다.

 

16.4.2. The Stanford Natural Language Inference (SNLI) Dataset

 

Stanford Natural Language Inference (SNLI) Corpus is a collection of over 500000 labeled English sentence pairs (Bowman et al., 2015). We download and store the extracted SNLI dataset in the path ../data/snli_1.0.

 

SNLI(Stanford Natural Language Inference) 코퍼스는 500,000개가 넘는 레이블이 있는 영어 문장 쌍의 모음입니다(Bowman et al., 2015). 추출된 SNLI 데이터 세트를 다운로드하여 ../data/snli_1.0 경로에 저장합니다.

 

import os
import re
import torch
from torch import nn
from d2l import torch as d2l

#@save
d2l.DATA_HUB['SNLI'] = (
    'https://nlp.stanford.edu/projects/snli/snli_1.0.zip',
    '9fcde07509c7e87ec61c640c1b2753d9041758e4')

data_dir = d2l.download_extract('SNLI')

이 코드는 SNLI 데이터셋을 다운로드하고 압축을 해제하는 파이토치 코드입니다. 코드의 작동 방식을 설명하겠습니다.

1. 필요한 라이브러리 및 모듈 임포트:
   • import os: 파일 및 디렉터리 경로를 조작하기 위한 파이썬 기본 모듈입니다.
   • import re: 정규 표현식을 활용하기 위한 모듈입니다.
   • import torch: 파이토치 라이브러리입니다.
   • from torch import nn: 파이토치의 신경망 모듈을 임포트합니다.
   • from d2l import torch as d2l: 'd2l' 모듈에서 'torch' 모듈을 임포트하고, 'd2l'이라는 이름으로 사용합니다.
2. 데이터셋 정보 설정:
   • d2l.DATA_HUB['SNLI']: SNLI 데이터셋에 대한 정보를 딕셔너리로 지정합니다. 데이터셋의 URL과 파일 해시값을 포함합니다.
   • data_dir = d2l.download_extract('SNLI'): 'd2l' 라이브러리의 download_extract 함수를 사용하여 SNLI 데이터셋을 다운로드하고 압축을 해제합니다. 데이터셋의 압축이 해제된 경로를 data_dir 변수에 저장합니다.

결과적으로, 이 코드는 SNLI 데이터셋을 다운로드하고 압축을 해제하여 사용할 준비를 하는 과정을 수행합니다. 이 데이터셋은 자연어 처리 작업에서 활용되며, 모델 학습 및 평가에 사용될 수 있습니다.

 

 

16.4.2.1. Reading the Dataset

The original SNLI dataset contains much richer information than what we really need in our experiments. Thus, we define a function read_snli to only extract part of the dataset, then return lists of premises, hypotheses, and their labels.

 

원본 SNLI 데이터 세트에는 실험에 실제로 필요한 것보다 훨씬 더 풍부한 정보가 포함되어 있습니다. 따라서 우리는 데이터 세트의 일부만 추출한 다음 전제, 가설 및 해당 레이블 목록을 반환하도록 read_snli 함수를 정의합니다.

 

#@save
def read_snli(data_dir, is_train):
    """Read the SNLI dataset into premises, hypotheses, and labels."""
    def extract_text(s):
        # Remove information that will not be used by us
        s = re.sub('\\(', '', s)
        s = re.sub('\\)', '', s)
        # Substitute two or more consecutive whitespace with space
        s = re.sub('\\s{2,}', ' ', s)
        return s.strip()
    label_set = {'entailment': 0, 'contradiction': 1, 'neutral': 2}
    file_name = os.path.join(data_dir, 'snli_1.0_train.txt'
                             if is_train else 'snli_1.0_test.txt')
    with open(file_name, 'r') as f:
        rows = [row.split('\t') for row in f.readlines()[1:]]
    premises = [extract_text(row[1]) for row in rows if row[0] in label_set]
    hypotheses = [extract_text(row[2]) for row in rows if row[0] in label_set]
    labels = [label_set[row[0]] for row in rows if row[0] in label_set]
    return premises, hypotheses, labels

이 코드는 SNLI 데이터셋을 읽어와 문장 및 레이블을 추출하는 함수를 정의하는 파이토치 코드입니다. 코드의 작동 방식을 설명하겠습니다.

1. 함수 정의:
   • read_snli(data_dir, is_train): SNLI 데이터셋을 읽어와 문장과 레이블을 추출하는 함수입니다. data_dir은 데이터셋이 위치한 디렉터리 경로이고, is_train은 훈련 데이터인지 여부를 나타내는 변수입니다.
2. 문장 추출 및 전처리:
   • extract_text(s): 주어진 문자열 s를 전처리하는 함수입니다. 괄호 및 공백을 제거하고, 연속된 공백을 하나의 공백으로 대체한 후 양쪽 공백을 제거하여 문장을 정리합니다.
3. 레이블 설정:
   • label_set: 레이블과 해당하는 숫자를 매핑한 딕셔너리입니다.
4. 데이터 파일 읽기:
   • file_name: 데이터 파일 경로를 설정합니다. is_train에 따라 훈련 데이터 또는 테스트 데이터 파일을 선택합니다.
   • with open(file_name, 'r') as f:: 파일을 열고 읽기 모드로 처리합니다.
   • rows = [row.split('\t') for row in f.readlines()[1:]]: 파일에서 읽은 각 행을 탭으로 분리하여 리스트로 변환합니다. 첫 번째 행은 헤더이므로 무시합니다.
5. 문장 및 레이블 추출:
   • premises, hypotheses, labels: 각 행에서 필요한 정보를 추출하여 각각의 리스트에 저장합니다. 레이블은 label_set을 이용하여 숫자로 변환합니다.

결과적으로, 이 함수는 데이터 디렉터리에서 SNLI 데이터셋을 읽어와 전처리된 문장과 레이블을 추출하여 반환하는 역할을 수행합니다.

 

Now let’s print the first 3 pairs of premise and hypothesis, as well as their labels (“0”, “1”, and “2” correspond to “entailment”, “contradiction”, and “neutral”, respectively ).

 

이제 전제와 가설의 처음 3쌍과 해당 레이블("0", "1" 및 "2"는 각각 "수반", "모순" 및 "중립"에 해당)을 인쇄해 보겠습니다.

 

train_data = read_snli(data_dir, is_train=True)
for x0, x1, y in zip(train_data[0][:3], train_data[1][:3], train_data[2][:3]):
    print('premise:', x0)
    print('hypothesis:', x1)
    print('label:', y)

이 코드는 SNLI 데이터셋에서 훈련 데이터를 읽어와 문장과 레이블을 출력하는 작업을 수행하는 파이토치 코드입니다. 코드의 작동 방식을 설명하겠습니다.

1. 훈련 데이터 읽기:
   • train_data = read_snli(data_dir, is_train=True): read_snli 함수를 사용하여 훈련 데이터를 읽어옵니다. 이 함수는 premises, hypotheses, labels를 반환합니다.
2. 데이터 출력:
   • for x0, x1, y in zip(train_data[0][:3], train_data[1][:3], train_data[2][:3]):: 훈련 데이터에서 처음 3개의 데이터에 대해서 반복문을 실행합니다. x0는 premises, x1은 hypotheses, y는 labels를 나타냅니다.
   • print('premise:', x0): 현재 반복에서 추출한 premises를 출력합니다.
   • print('hypothesis:', x1): 현재 반복에서 추출한 hypotheses를 출력합니다.
   • print('label:', y): 현재 반복에서 추출한 label을 출력합니다.

결과적으로, 이 코드는 훈련 데이터에서 처음 3개의 문장과 해당하는 가설, 레이블을 출력하여 데이터가 올바르게 읽혔는지 확인하는 역할을 수행합니다.

premise: A person on a horse jumps over a broken down airplane .
hypothesis: A person is training his horse for a competition .
label: 2
premise: A person on a horse jumps over a broken down airplane .
hypothesis: A person is at a diner , ordering an omelette .
label: 1
premise: A person on a horse jumps over a broken down airplane .
hypothesis: A person is outdoors , on a horse .
label: 0

The training set has about 550000 pairs, and the testing set has about 10000 pairs. The following shows that the three labels “entailment”, “contradiction”, and “neutral” are balanced in both the training set and the testing set.

 

훈련 세트에는 약 550000개의 쌍이 있고 테스트 세트에는 약 10000개의 쌍이 있습니다. 다음은 "수반", "모순" 및 "중립"이라는 세 가지 레이블이 훈련 세트와 테스트 세트 모두에서 균형을 이루고 있음을 보여줍니다.

 

test_data = read_snli(data_dir, is_train=False)
for data in [train_data, test_data]:
    print([[row for row in data[2]].count(i) for i in range(3)])

이 코드는 SNLI 데이터셋에서 훈련 데이터와 테스트 데이터의 레이블 분포를 출력하는 작업을 수행하는 파이토치 코드입니다. 코드의 작동 방식을 설명하겠습니다.

1. 테스트 데이터 읽기:
   • test_data = read_snli(data_dir, is_train=False): read_snli 함수를 사용하여 테스트 데이터를 읽어옵니다. 이 함수는 premises, hypotheses, labels를 반환합니다. is_train을 False로 설정하여 테스트 데이터를 가져옵니다.
2. 레이블 분포 출력:
   • for data in [train_data, test_data]:: 훈련 데이터와 테스트 데이터에 대해 각각 반복문을 실행합니다.
   • print([[row for row in data[2]].count(i) for i in range(3)]): 각 데이터의 레이블 분포를 출력합니다. 각 레이블(0, 1, 2)별로 데이터에서 해당 레이블의 개수를 계산하여 출력합니다.

결과적으로, 이 코드는 훈련 데이터와 테스트 데이터에서 각 레이블(0, 1, 2)별로 데이터의 분포를 출력하여 어떤 레이블이 얼마나 많은지를 확인하는 역할을 수행합니다.

[183416, 183187, 182764]
[3368, 3237, 3219]

 

16.4.2.2. Defining a Class for Loading the Dataset

Below we define a class for loading the SNLI dataset by inheriting from the Dataset class in Gluon. The argument num_steps in the class constructor specifies the length of a text sequence so that each minibatch of sequences will have the same shape. In other words, tokens after the first num_steps ones in longer sequence are trimmed, while special tokens “<pad>” will be appended to shorter sequences until their length becomes num_steps. By implementing the __getitem__ function, we can arbitrarily access the premise, hypothesis, and label with the index idx.

 

아래에서는 Gluon의 Dataset 클래스를 상속하여 SNLI 데이터 세트를 로드하기 위한 클래스를 정의합니다. 클래스 생성자의 num_steps 인수는 각 시퀀스 미니 배치가 동일한 모양을 갖도록 텍스트 시퀀스의 길이를 지정합니다. 즉, 긴 시퀀스에서 첫 번째 num_steps 이후의 토큰은 잘리는 반면, 특수 토큰 "<pad>"는 길이가 num_steps가 될 때까지 더 짧은 시퀀스에 추가됩니다. __getitem__ 함수를 구현하면 인덱스 idx로 전제, 가설, 레이블에 임의로 접근할 수 있습니다.

 

#@save
class SNLIDataset(torch.utils.data.Dataset):
    """A customized dataset to load the SNLI dataset."""
    def __init__(self, dataset, num_steps, vocab=None):
        self.num_steps = num_steps
        all_premise_tokens = d2l.tokenize(dataset[0])
        all_hypothesis_tokens = d2l.tokenize(dataset[1])
        if vocab is None:
            self.vocab = d2l.Vocab(all_premise_tokens + all_hypothesis_tokens,
                                   min_freq=5, reserved_tokens=['<pad>'])
        else:
            self.vocab = vocab
        self.premises = self._pad(all_premise_tokens)
        self.hypotheses = self._pad(all_hypothesis_tokens)
        self.labels = torch.tensor(dataset[2])
        print('read ' + str(len(self.premises)) + ' examples')

    def _pad(self, lines):
        return torch.tensor([d2l.truncate_pad(
            self.vocab[line], self.num_steps, self.vocab['<pad>'])
                         for line in lines])

    def __getitem__(self, idx):
        return (self.premises[idx], self.hypotheses[idx]), self.labels[idx]

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

 

위의 코드는 SNLI(Sentence Natural Language Inference) 데이터셋을 로드하기 위한 사용자 정의 데이터셋 클래스인 SNLIDataset을 정의하는 부분입니다. 이 클래스는 PyTorch의 torch.utils.data.Dataset 클래스를 상속하여 구현되었습니다.

 

이 클래스의 주요 목적은 SNLI 데이터를 모델에 입력으로 공급하기 위한 데이터 파이프라인을 구축하는 것입니다. 이 데이터셋은 주어진 문장 쌍(전제문과 가설문)에 대한 텍스트와 해당 라벨(문장 간의 관계)을 처리합니다.

클래스 내부에서 다음 주요 구성 요소를 확인할 수 있습니다.

 

• __init__: 데이터셋의 초기화 함수입니다. 이 함수는 다음 인자들을 받습니다.
  • dataset: 데이터셋으로부터 읽은 원시 데이터 (전제문, 가설문, 라벨)입니다.
  • num_steps: 데이터의 시퀀스 길이를 지정하는 인자로, 긴 시퀀스를 자르거나 패딩하는 데 사용됩니다.
  • vocab: 선택적으로 전달되는 어휘 사전입니다. 어휘 사전을 직접 제공하지 않으면, 데이터셋에서 자동으로 어휘 사전을 생성합니다.
• _pad: 시퀀스를 주어진 num_steps 길이로 패딩하고 어휘 사전에 맞게 인덱스로 변환하는 내부 함수입니다.
• __getitem__: 데이터셋에서 데이터를 로드할 때 호출되는 함수로, 주어진 인덱스 idx에 해당하는 전제문과 가설문, 그리고 라벨을 반환합니다.
• __len__: 데이터셋의 전체 샘플 수를 반환하는 함수입니다.

SNLIDataset 클래스를 사용하면 SNLI 데이터셋을 쉽게 PyTorch 데이터로 변환하고 데이터 로더를 통해 모델에 공급할 수 있습니다

16.4.2.3. Putting It All Together

Now we can invoke the read_snli function and the SNLIDataset class to download the SNLI dataset and return DataLoader instances for both training and testing sets, together with the vocabulary of the training set. It is noteworthy that we must use the vocabulary constructed from the training set as that of the testing set. As a result, any new token from the testing set will be unknown to the model trained on the training set.

 

이제 read_snli 함수와 SNLIDataset 클래스를 호출하여 SNLI 데이터 세트를 다운로드하고 훈련 세트의 어휘와 함께 훈련 세트와 테스트 세트 모두에 대한 DataLoader 인스턴스를 반환할 수 있습니다. 훈련 세트에서 구성된 어휘를 테스트 세트의 어휘로 사용해야 한다는 점은 주목할 만합니다. 결과적으로 테스트 세트의 새로운 토큰은 훈련 세트에서 훈련된 모델에 알려지지 않습니다.

 

#@save
def load_data_snli(batch_size, num_steps=50):
    """Download the SNLI dataset and return data iterators and vocabulary."""
    num_workers = d2l.get_dataloader_workers()
    data_dir = d2l.download_extract('SNLI')
    train_data = read_snli(data_dir, True)
    test_data = read_snli(data_dir, False)
    train_set = SNLIDataset(train_data, num_steps)
    test_set = SNLIDataset(test_data, num_steps, train_set.vocab)
    train_iter = torch.utils.data.DataLoader(train_set, batch_size,
                                             shuffle=True,
                                             num_workers=num_workers)
    test_iter = torch.utils.data.DataLoader(test_set, batch_size,
                                            shuffle=False,
                                            num_workers=num_workers)
    return train_iter, test_iter, train_set.vocab

위의 코드는 SNLI(Sentence Natural Language Inference) 데이터셋을 다운로드하고 데이터 반복자(data iterators)와 어휘 사전(vocabulary)을 반환하는 함수인 load_data_snli를 정의한 부분입니다. 이 함수를 통해 데이터를 준비하고 모델에 공급할 수 있는 형태로 만듭니다.

 

주요 구성 요소와 작업 단계는 다음과 같습니다.

 

• num_workers: 데이터 로더에 사용할 병렬 작업자 수를 결정하는 변수입니다.
• data_dir: 데이터셋 파일이 저장될 디렉토리를 지정하는 변수입니다.
• train_data와 test_data: read_snli 함수를 사용하여 SNLI 데이터셋을 읽어온 원시 데이터입니다.
• train_set과 test_set: SNLIDataset 클래스를 사용하여 데이터를 전처리하고 PyTorch 데이터셋 형식으로 변환한 데이터셋입니다. 각 데이터셋에는 전제문과 가설문의 시퀀스, 그리고 문장 간의 관계를 나타내는 라벨이 포함되어 있습니다.
• train_iter와 test_iter: torch.utils.data.DataLoader를 사용하여 배치(batch) 단위로 데이터를 불러오는 데이터 반복자입니다. 이 반복자들은 모델 학습 및 평가에 사용됩니다.
• train_set.vocab: 데이터셋의 어휘 사전입니다. 이 어휘 사전은 전체 데이터셋의 어휘를 관리하며, 텍스트 데이터를 숫자로 변환하는 데 사용됩니다.

이 함수를 호출하면 학습용(train_iter)과 테스트용(test_iter) 데이터 반복자와 어휘 사전(train_set.vocab)이 반환됩니다. 이러한 데이터 반복자와 어휘 사전을 사용하여 모델 학습 및 평가를 수행할 수 있습니다.

 

Here we set the batch size to 128 and sequence length to 50, and invoke the load_data_snli function to get the data iterators and vocabulary. Then we print the vocabulary size.

 

여기서는 배치 크기를 128로 설정하고 시퀀스 길이를 50으로 설정하고 load_data_snli 함수를 호출하여 데이터 반복자와 어휘를 가져옵니다. 그런 다음 어휘 크기를 인쇄합니다.

 

train_iter, test_iter, vocab = load_data_snli(128, 50)
len(vocab)

이 코드는 SNLI 데이터셋을 로드하여 데이터 반복자(train_iter, test_iter)와 어휘 사전(vocab)을 생성하고, 어휘 사전의 크기를 출력하는 작업을 수행하는 파이토치 코드입니다. 코드의 작동 방식을 설명하겠습니다.

1. 데이터 로드 및 어휘 생성:
   • train_iter, test_iter, vocab = load_data_snli(128, 50): load_data_snli 함수를 사용하여 SNLI 데이터셋을 로드하고 데이터 반복자(train_iter, test_iter)와 어휘 사전(vocab)을 생성합니다. 인자로 배치 크기(128)와 문장의 최대 토큰 개수(50)를 전달합니다.
2. 어휘 사전 크기 출력:
   • len(vocab): 생성된 어휘 사전의 크기를 출력합니다. 이 값은 어휘 사전에 등록된 고유한 단어의 개수를 나타냅니다.

결과적으로, 이 코드는 SNLI 데이터셋을 로드하고 어휘 사전을 생성한 후, 생성된 어휘 사전의 크기를 출력하여 데이터 처리 과정의 결과를 확인하는 역할을 수행합니다.

read 549367 examples
read 9824 examples

18678

Now we print the shape of the first minibatch. Contrary to sentiment analysis, we have two inputs X[0] and X[1] representing pairs of premises and hypotheses.

 

이제 첫 번째 미니배치의 모양을 인쇄합니다. 감정 분석과 달리 전제와 가설의 쌍을 나타내는 두 개의 입력 X[0] 및 X[1]이 있습니다.

 

for X, Y in train_iter:
    print(X[0].shape)
    print(X[1].shape)
    print(Y.shape)
    break

위의 코드는 학습 데이터 반복자(train_iter)를 통해 첫 번째 미니배치(mini-batch) 데이터를 가져와서 각 구성 요소의 모양(shape)을 출력하는 부분입니다. 이 코드를 통해 데이터의 형태를 이해할 수 있습니다.

• for X, Y in train_iter:: 학습 데이터 반복자인 train_iter를 순회하며 각 미니배치를 가져옵니다. X는 입력 데이터, Y는 해당 입력에 대한 라벨(정답)을 나타냅니다.
• print(X[0].shape): 현재 미니배치의 첫 번째 요소 X[0]의 모양(shape)을 출력합니다. 여기서 X[0]은 입력 데이터 중 첫 번째 시퀀스에 해당합니다.
• print(X[1].shape): 현재 미니배치의 두 번째 요소 X[1]의 모양(shape)을 출력합니다. X[1]은 입력 데이터 중 두 번째 시퀀스에 해당합니다.
• print(Y.shape): 현재 미니배치의 라벨(정답) 데이터 Y의 모양(shape)을 출력합니다.
• break: 첫 번째 미니배치의 출력 후에 반복문을 종료합니다. 이 부분은 미니배치의 구성 요소를 확인하기 위한 간단한 디버깅 용도로 사용됩니다.

이 코드를 실행하면 첫 번째 미니배치의 입력 데이터와 라벨의 모양을 확인할 수 있으며, 이를 통해 모델을 설계할 때 입력 및 출력의 형태를 정확하게 지정하는 데 도움이 됩니다.

torch.Size([128, 50])
torch.Size([128, 50])
torch.Size([128])

 

16.4.3. Summary

• Natural language inference studies whether a hypothesis can be inferred from a premise, where both are a text sequence.
  
  자연어 추론은 둘 다 텍스트 시퀀스인 전제로부터 가설을 추론할 수 있는지 여부를 연구합니다.
  
  
• In natural language inference, relationships between premises and hypotheses include entailment, contradiction, and neutral.
  
  자연어 추론에서 전제와 가설 사이의 관계에는 수반, 모순, 중립이 포함됩니다.
  
  
• Stanford Natural Language Inference (SNLI) Corpus is a popular benchmark dataset of natural language inference.
  
  SNLI(Stanford Natural Language Inference) 코퍼스는 자연어 추론에 대한 인기 있는 벤치마크 데이터세트입니다.
  
  

 

16.4.4. Exercises

1. Machine translation has long been evaluated based on superficial n-gram matching between an output translation and a ground-truth translation. Can you design a measure for evaluating machine translation results by using natural language inference?
2. How can we change hyperparameters to reduce the vocabulary size?