D2L - 15.10. Pretraining BERT

15.10. Pretraining BERT — Dive into Deep Learning 1.0.3 documentation (d2l.ai)

15.10. Pretraining BERT — Dive into Deep Learning 1.0.3 documentation

 

15.10. Pretraining BERT

 

With the BERT model implemented in Section 15.8 and the pretraining examples generated from the WikiText-2 dataset in Section 15.9, we will pretrain BERT on the WikiText-2 dataset in this section.

 

섹션 15.8에서 구현된 BERT 모델과 섹션 15.9의 WikiText-2 데이터 세트에서 생성된 사전 학습 예제를 사용하여 이 섹션에서는 WikiText-2 데이터 세트에 대해 BERT를 사전 학습할 것입니다.

 

import torch
from torch import nn
from d2l import torch as d2l

 

To start, we load the WikiText-2 dataset as minibatches of pretraining examples for masked language modeling and next sentence prediction. The batch size is 512 and the maximum length of a BERT input sequence is 64. Note that in the original BERT model, the maximum length is 512.

 

시작하려면 WikiText-2 데이터 세트를 마스크된 언어 모델링 및 다음 문장 예측을 위한 사전 학습 예제의 미니 배치로 로드합니다. 배치 크기는 512이고 BERT 입력 시퀀스의 최대 길이는 64입니다. 원래 BERT 모델에서 최대 길이는 512입니다.

 

batch_size, max_len = 512, 64
train_iter, vocab = d2l.load_data_wiki(batch_size, max_len)

위의 코드에서 이루어지는 작업은 다음과 같습니다:

1. batch_size와 max_len 설정: 미니 배치 크기와 최대 시퀀스 길이를 설정합니다.
2. 데이터 로드 및 데이터로더 생성: d2l.load_data_wiki 함수를 호출하여 WikiText-2 데이터셋을 로드하고, 데이터로더를 생성합니다.

이렇게 생성된 train_iter는 미니 배치 데이터를 반복적으로 제공하며, vocab은 데이터셋에 등장하는 단어들의 어휘 사전을 나타냅니다. 이렇게 생성된 데이터로더와 어휘 사전은 BERT 모델 학습을 위해 사용될 수 있습니다.

15.10.1. Pretraining BERT

The original BERT has two versions of different model sizes (Devlin et al., 2018). The base model (BERTBASE) uses 12 layers (Transformer encoder blocks) with 768 hidden units (hidden size) and 12 self-attention heads. The large model (BERTLARGE) uses 24 layers with 1024 hidden units and 16 self-attention heads. Notably, the former has 110 million parameters while the latter has 340 million parameters. For demonstration with ease, we define a small BERT, using 2 layers, 128 hidden units, and 2 self-attention heads.

 

원래 BERT에는 서로 다른 모델 크기의 두 가지 버전이 있습니다(Devlin et al., 2018). 기본 모델(BERTBASE)은 768개의 숨겨진 유닛(숨겨진 크기)과 12개의 self-attention 헤드가 있는 12개의 레이어(변환기 인코더 블록)를 사용합니다. 대형 모델(BERTLARGE)은 1024개의 숨겨진 유닛과 16개의 self-attention 헤드가 포함된 24개의 레이어를 사용합니다. 특히 전자에는 1억 1천만 개의 매개변수가 있고 후자에는 3억 4천만 개의 매개변수가 있습니다. 쉽게 시연하기 위해 2개의 레이어, 128개의 숨겨진 유닛, 2개의 self-attention 헤드를 사용하여 작은 BERT를 정의합니다.

 

net = d2l.BERTModel(len(vocab), num_hiddens=128,
                    ffn_num_hiddens=256, num_heads=2, num_blks=2, dropout=0.2)
devices = d2l.try_all_gpus()
loss = nn.CrossEntropyLoss()

위의 코드에서 이루어지는 작업은 다음과 같습니다:

BERT 모델 생성: d2l.BERTModel 클래스를 이용하여 BERT 모델을 생성합니다. 인자로는 어휘 사전 크기 len(vocab)와 모델의 히든 차원 수 num_hiddens, 피드포워드 신경망의 히든 차원 수 ffn_num_hiddens, 어텐션 헤드 수 num_heads, 블록 수 num_blks, 드롭아웃 비율 dropout 등이 설정됩니다.

 

디바이스 할당: d2l.try_all_gpus() 함수를 호출하여 가능한 GPU 장치들 중에서 사용 가능한 장치들의 리스트를 가져옵니다. 이렇게 얻은 장치 리스트는 모델 학습을 GPU에서 병렬적으로 처리하기 위해 사용될 수 있습니다.

 

손실 함수 설정: 분류 작업을 위한 크로스 엔트로피 손실 함수 nn.CrossEntropyLoss()를 생성합니다. 이 함수는 모델의 출력과 실제 타겟 간의 손실을 계산합니다.

 

이렇게 생성된 BERT 모델과 관련된 요소들은 이후 학습과 평가를 수행하는 단계에서 사용됩니다.

 

Before defining the training loop, we define a helper function _get_batch_loss_bert. Given the shard of training examples, this function computes the loss for both the masked language modeling and next sentence prediction tasks. Note that the final loss of BERT pretraining is just the sum of both the masked language modeling loss and the next sentence prediction loss.

 

훈련 루프를 정의하기 전에 도우미 함수 _get_batch_loss_bert를 정의합니다. 훈련 예제의 조각이 주어지면 이 함수는 마스크된 언어 모델링과 다음 문장 예측 작업 모두에 대한 손실을 계산합니다. BERT 사전 훈련의 최종 손실은 마스크된 언어 모델링 손실과 다음 문장 예측 손실의 합일 뿐입니다.

 

#@save
def _get_batch_loss_bert(net, loss, vocab_size, tokens_X,
                         segments_X, valid_lens_x,
                         pred_positions_X, mlm_weights_X,
                         mlm_Y, nsp_y):
    # Forward pass
    _, mlm_Y_hat, nsp_Y_hat = net(tokens_X, segments_X,
                                  valid_lens_x.reshape(-1),
                                  pred_positions_X)
    # Compute masked language model loss
    mlm_l = loss(mlm_Y_hat.reshape(-1, vocab_size), mlm_Y.reshape(-1)) *\
    mlm_weights_X.reshape(-1, 1)
    mlm_l = mlm_l.sum() / (mlm_weights_X.sum() + 1e-8)
    # Compute next sentence prediction loss
    nsp_l = loss(nsp_Y_hat, nsp_y)
    l = mlm_l + nsp_l
    return mlm_l, nsp_l, l

위의 함수는 아래 작업을 수행합니다:

1. Forward Pass: 입력 데이터인 tokens_X, segments_X, valid_lens_x, pred_positions_X를 BERT 모델 net에 전달하여 순전파를 수행합니다. 이 과정에서 얻어진 출력은 mlm_Y_hat (마스킹된 언어 모델의 예측)와 nsp_Y_hat (다음 문장 예측의 예측)입니다.
2. 마스킹된 언어 모델 손실 계산: mlm_Y_hat와 실제 레이블 mlm_Y 간의 손실을 계산합니다. 이 손실은 마스킹된 토큰들에 대해서만 계산되며, 마스킹된 토큰의 가중치 mlm_weights_X를 고려하여 계산된 다음, 이를 마스킹된 토큰의 총 가중치 합으로 나누어 정규화합니다.
3. 다음 문장 예측 손실 계산: nsp_Y_hat와 실제 레이블 nsp_y 간의 손실을 계산합니다.
4. 총 손실 계산: 마스킹된 언어 모델 손실과 다음 문장 예측 손실을 더한 총 손실을 계산합니다.

즉, 이 함수는 하나의 미니배치 데이터에 대해 BERT 모델의 마스킹된 언어 모델 손실과 다음 문장 예측 손실을 계산하고, 이들 손실을 합산한 총 손실을 반환합니다. 이 손실 값은 학습 단계에서 최적화(optimizer)를 위해 사용됩니다

 

Invoking the two aforementioned helper functions, the following train_bert function defines the procedure to pretrain BERT (net) on the WikiText-2 (train_iter) dataset. Training BERT can take very long. Instead of specifying the number of epochs for training as in the train_ch13 function (see Section 14.1), the input num_steps of the following function specifies the number of iteration steps for training.

 

앞서 언급한 두 도우미 함수를 호출하는 다음 train_bert 함수는 WikiText-2(train_iter) 데이터 세트에서 BERT(net)를 사전 훈련하는 절차를 정의합니다. BERT 훈련은 매우 오랜 시간이 걸릴 수 있습니다. train_ch13 함수(14.1절 참조)에서처럼 훈련을 위한 에포크 수를 지정하는 대신, 다음 함수의 입력 num_steps는 훈련을 위한 반복 단계 수를 지정합니다.

 

def train_bert(train_iter, net, loss, vocab_size, devices, num_steps):
    net(*next(iter(train_iter))[:4])
    net = nn.DataParallel(net, device_ids=devices).to(devices[0])
    trainer = torch.optim.Adam(net.parameters(), lr=0.01)
    step, timer = 0, d2l.Timer()
    animator = d2l.Animator(xlabel='step', ylabel='loss',
                            xlim=[1, num_steps], legend=['mlm', 'nsp'])
    # Sum of masked language modeling losses, sum of next sentence prediction
    # losses, no. of sentence pairs, count
    metric = d2l.Accumulator(4)
    num_steps_reached = False
    while step < num_steps and not num_steps_reached:
        for tokens_X, segments_X, valid_lens_x, pred_positions_X,\
            mlm_weights_X, mlm_Y, nsp_y in train_iter:
            tokens_X = tokens_X.to(devices[0])
            segments_X = segments_X.to(devices[0])
            valid_lens_x = valid_lens_x.to(devices[0])
            pred_positions_X = pred_positions_X.to(devices[0])
            mlm_weights_X = mlm_weights_X.to(devices[0])
            mlm_Y, nsp_y = mlm_Y.to(devices[0]), nsp_y.to(devices[0])
            trainer.zero_grad()
            timer.start()
            mlm_l, nsp_l, l = _get_batch_loss_bert(
                net, loss, vocab_size, tokens_X, segments_X, valid_lens_x,
                pred_positions_X, mlm_weights_X, mlm_Y, nsp_y)
            l.backward()
            trainer.step()
            metric.add(mlm_l, nsp_l, tokens_X.shape[0], 1)
            timer.stop()
            animator.add(step + 1,
                         (metric[0] / metric[3], metric[1] / metric[3]))
            step += 1
            if step == num_steps:
                num_steps_reached = True
                break

    print(f'MLM loss {metric[0] / metric[3]:.3f}, '
          f'NSP loss {metric[1] / metric[3]:.3f}')
    print(f'{metric[2] / timer.sum():.1f} sentence pairs/sec on '
          f'{str(devices)}')

 

위의 함수는 아래 작업을 수행합니다:

1. 모델 초기화: 먼저 net에 한 미니배치 데이터를 전달하여 모델을 초기화합니다. 이는 BERT 모델을 GPU에 병렬로 배치하기 위한 사전작업입니다.
2. 모델 병렬화 및 옵티마이저 설정: 모델을 병렬화하여 다중 GPU에서 학습할 수 있도록 준비하고, Adam 옵티마이저를 설정합니다.
3. 학습 루프: 학습 루프는 주어진 num_steps만큼 반복하여 BERT 모델을 학습합니다. 미니배치 데이터를 하나씩 가져와 GPU로 이동시킨 후, _get_batch_loss_bert 함수를 호출하여 마스킹된 언어 모델 손실과 다음 문장 예측 손실을 계산합니다. 그런 다음 손실을 역전파하고 옵티마이저를 통해 모델의 파라미터를 업데이트합니다.
4. 손실 및 성능 측정: _get_batch_loss_bert 함수에서 계산한 마스킹된 언어 모델 손실과 다음 문장 예측 손실을 누적하여 기록하고, 성능 지표를 계산합니다. 이후 학습의 진행 상황을 애니메이션으로 표시합니다.
5. 학습 결과 출력: 학습이 완료되면 마스킹된 언어 모델 손실과 다음 문장 예측 손실을 출력하며, 학습 속도를 표시합니다.

즉, 이 함수는 BERT 모델을 주어진 데이터로 학습시키는 데 사용되며, 모델의 학습 손실 및 성능 지표를 출력합니다.

 

모델 초기화와 병렬화

net(*next(iter(train_iter))[:4])
net = nn.DataParallel(net, device_ids=devices).to(devices[0])

 

첫 번째 줄에서는 미니배치 데이터의 첫 번째 요소를 가져와 모델에 전달하여 초기화합니다. 이는 모델을 GPU에 병렬로 배치하기 위해 필요한 작업입니다.

 

두 번째 줄에서는 nn.DataParallel을 사용하여 모델을 다중 GPU로 병렬화합니다. device_ids 매개변수를 통해 사용할 GPU를 선택하고, .to(devices[0])를 사용하여 모델을 첫 번째 GPU로 이동시킵니다. 이렇게 함으로써 모델을 다중 GPU에서 병렬로 학습할 수 있도록 준비합니다.

 

옵티마이저 설정

trainer = torch.optim.Adam(net.parameters(), lr=0.01)

Adam 옵티마이저를 설정합니다. net.parameters()를 통해 모델의 파라미터들을 가져와 옵티마이저에 전달하고, lr 매개변수를 통해 학습률을 설정합니다.

 

학습 루프

for tokens_X, segments_X, valid_lens_x, pred_positions_X,\
    mlm_weights_X, mlm_Y, nsp_y in train_iter:
    # ...

학습 루프에서는 주어진 train_iter 데이터로 BERT 모델을 학습합니다. 데이터를 하나씩 가져와서 다음 작업을 수행합니다:

1. 데이터를 GPU로 이동시킵니다.
2. 옵티마이저의 그래디언트를 초기화합니다.
3. _get_batch_loss_bert 함수를 호출하여 마스킹된 언어 모델 손실과 다음 문장 예측 손실을 계산합니다.
4. 역전파를 수행하고 옵티마이저를 통해 모델 파라미터를 업데이트합니다.
5. 손실과 성능 지표를 기록합니다.

손실 및 성능 측정

mlm_l, nsp_l, l = _get_batch_loss_bert(
    net, loss, vocab_size, tokens_X, segments_X, valid_lens_x,
    pred_positions_X, mlm_weights_X, mlm_Y, nsp_y)
metric.add(mlm_l, nsp_l, tokens_X.shape[0], 1)

_get_batch_loss_bert 함수를 통해 계산된 마스킹된 언어 모델 손실과 다음 문장 예측 손실을 기록하고, 해당 미니배치의 문장 쌍 수와 학습한 미니배치 수를 누적합니다. 이 정보는 학습 과정에서 손실과 성능 지표를 계산하고 모니터링하는 데 사용됩니다.

 

print(f'MLM loss {metric[0] / metric[3]:.3f}, '
      f'NSP loss {metric[1] / metric[3]:.3f}')
print(f'{metric[2] / timer.sum():.1f} sentence pairs/sec on '
      f'{str(devices)}')

 

학습이 완료되면 마스킹된 언어 모델 손실과 다음 문장 예측 손실을 출력하며, 학습 속도를 표시합니다. metric[0]은 마스킹된 언어 모델 손실의 누적값, metric[1]은 다음 문장 예측 손실의 누적값, metric[2]는 학습한 문장 쌍의 수, `metric[3]

 

 

We can plot both the masked language modeling loss and the next sentence prediction loss during BERT pretraining.

 

BERT 사전 훈련 중 마스크된 언어 모델링 손실과 다음 문장 예측 손실을 모두 플롯할 수 있습니다.

 

train_bert(train_iter, net, loss, len(vocab), devices, 50)

위의 출력은 학습 결과를 보여줍니다.

• MLM loss 5.885: 마스킹된 언어 모델 손실의 평균 값입니다.
• NSP loss 0.760: 다음 문장 예측 손실의 평균 값입니다.
• 4413.2 sentence pairs/sec: 초당 처리된 문장 쌍의 수를 나타냅니다.
• on [device(type='cuda', index=0), device(type='cuda', index=1)]: 학습에 사용된 GPU 장치입니다. [device(type='cuda', index=0), device(type='cuda', index=1)]은 두 개의 GPU를 사용한다는 것을 나타냅니다.

이 출력을 통해 BERT 모델의 학습 과정과 손실 값, 학습 속도 등을 파악할 수 있습니다.

MLM loss 5.885, NSP loss 0.760
4413.2 sentence pairs/sec on [device(type='cuda', index=0), device(type='cuda', index=1)]

 

15.10.2. Representing Text with BERT

 

After pretraining BERT, we can use it to represent single text, text pairs, or any token in them. The following function returns the BERT (net) representations for all tokens in tokens_a and tokens_b.

 

BERT를 사전 훈련한 후 이를 사용하여 단일 텍스트, 텍스트 쌍 또는 그 안에 있는 모든 토큰을 나타낼 수 있습니다. 다음 함수는 tokens_a 및 tokens_b의 모든 토큰에 대한 BERT(net) 표현을 반환합니다.

 

def get_bert_encoding(net, tokens_a, tokens_b=None):
    tokens, segments = d2l.get_tokens_and_segments(tokens_a, tokens_b)
    token_ids = torch.tensor(vocab[tokens], device=devices[0]).unsqueeze(0)
    segments = torch.tensor(segments, device=devices[0]).unsqueeze(0)
    valid_len = torch.tensor(len(tokens), device=devices[0]).unsqueeze(0)
    encoded_X, _, _ = net(token_ids, segments, valid_len)
    return encoded_X

위의 코드는 주어진 입력 문장 또는 문장 쌍을 BERT 모델을 통해 인코딩하는 함수를 정의합니다. 각 매개변수의 역할을 살펴보겠습니다.

• net: BERT 모델 인스턴스입니다.
• tokens_a: 첫 번째 문장에 해당하는 토큰 리스트입니다.
• tokens_b: 두 번째 문장에 해당하는 토큰 리스트입니다. (옵션)

이 함수는 주어진 문장 또는 문장 쌍을 BERT 모델을 통해 인코딩하여 반환합니다. 구체적으로 다음 단계를 따릅니다.

1. d2l.get_tokens_and_segments(tokens_a, tokens_b) 함수를 사용하여 입력 토큰과 세그먼트 정보를 가져옵니다.
2. vocab[tokens]를 사용하여 토큰들을 정수 ID로 변환하고, 그 결과를 torch.tensor로 변환하고 unsqueeze(0)으로 차원을 추가하여 텐서를 생성합니다. 이 텐서는 BERT 모델에 입력됩니다.
3. token_ids와 세그먼트 정보, 그리고 문장 길이 정보(valid_len)를 사용하여 BERT 모델에 인코딩을 요청합니다.

 

Consider the sentence “a crane is flying”. Recall the input representation of BERT as discussed in Section 15.8.4. After inserting special tokens “<cls>” (used for classification) and “<sep>” (used for separation), the BERT input sequence has a length of six. Since zero is the index of the “<cls>” token, encoded_text[:, 0, :] is the BERT representation of the entire input sentence. To evaluate the polysemy token “crane”, we also print out the first three elements of the BERT representation of the token.

 

“a crane is flying”라는 문장을 생각해 보세요. 섹션 15.8.4에서 논의된 BERT의 입력 표현을 상기해보세요. 특수 토큰 “<cls>”(분류에 사용) 및 “<sep>”(분리에 사용)을 삽입한 후 BERT 입력 시퀀스의 길이는 6입니다. 0은 "<cls>" 토큰의 인덱스이므로 Encoded_text[:, 0, :]는 전체 입력 문장의 BERT 표현입니다. 다의어 토큰 "crane"을 평가하기 위해 토큰의 BERT 표현의 처음 세 요소도 인쇄합니다.

 

tokens_a = ['a', 'crane', 'is', 'flying']
encoded_text = get_bert_encoding(net, tokens_a)
# Tokens: '<cls>', 'a', 'crane', 'is', 'flying', '<sep>'
encoded_text_cls = encoded_text[:, 0, :]
encoded_text_crane = encoded_text[:, 2, :]
encoded_text.shape, encoded_text_cls.shape, encoded_text_crane[0][:3]

위의 코드는 BERT 모델을 사용하여 입력 토큰 시퀀스를 인코딩한 결과를 추출하는 과정을 보여줍니다. 코드의 각 부분을 살펴보겠습니다.

• tokens_a: 인코딩하려는 입력 토큰 시퀀스입니다.
• encoded_text: get_bert_encoding 함수를 사용하여 입력 토큰 시퀀스를 BERT 모델을 통해 인코딩한 결과입니다.

위의 코드는 다음과 같은 작업을 수행합니다:

1. get_bert_encoding 함수를 호출하여 입력 토큰 시퀀스 tokens_a를 BERT 모델을 통해 인코딩한 결과를 encoded_text로 받습니다.
2. encoded_text는 3차원 텐서입니다. 첫 번째 차원은 배치 차원, 두 번째 차원은 토큰 시퀀스의 위치 (토큰의 위치), 세 번째 차원은 BERT 모델의 히든 상태의 차원입니다.
3. encoded_text_cls는 인코딩된 텍스트의 첫 번째 토큰인 <cls>의 히든 상태를 추출합니다.
4. encoded_text_crane은 인코딩된 텍스트에서 "crane" 토큰의 히든 상태를 추출합니다.
5. 마지막으로, encoded_text의 모양, encoded_text_cls의 모양, 그리고 encoded_text_crane의 처음 세 원소를 출력합니다.

이 코드를 실행하면 입력 토큰 시퀀스를 BERT 모델을 통해 인코딩한 결과와 해당 결과의 특정 위치에서 추출한 히든 상태를 확인할 수 있습니다

(torch.Size([1, 6, 128]),
 torch.Size([1, 128]),
 tensor([0.8414, 1.4830, 0.8226], device='cuda:0', grad_fn=<SliceBackward0>))

 

Now consider a sentence pair “a crane driver came” and “he just left”. Similarly, encoded_pair[:, 0, :] is the encoded result of the entire sentence pair from the pretrained BERT. Note that the first three elements of the polysemy token “crane” are different from those when the context is different. This supports that BERT representations are context-sensitive.

 

이제 "a crane driver came"와 "he just left"라는 문장 쌍을 생각해 보세요. 마찬가지로, Encoded_pair[:, 0, :]는 사전 훈련된 BERT의 전체 문장 쌍의 인코딩된 결과입니다. 다의어 토큰 "크레인"의 처음 세 요소는 문맥이 다를 때의 요소와 다릅니다. 이는 BERT 표현이 상황에 따라 달라지는 것을 지원합니다.

 

tokens_a, tokens_b = ['a', 'crane', 'driver', 'came'], ['he', 'just', 'left']
encoded_pair = get_bert_encoding(net, tokens_a, tokens_b)
# Tokens: '<cls>', 'a', 'crane', 'driver', 'came', '<sep>', 'he', 'just',
# 'left', '<sep>'
encoded_pair_cls = encoded_pair[:, 0, :]
encoded_pair_crane = encoded_pair[:, 2, :]
encoded_pair.shape, encoded_pair_cls.shape, encoded_pair_crane[0][:3]

위의 코드는 두 개의 입력 시퀀스를 BERT 모델을 통해 함께 인코딩하는 과정을 나타냅니다. 코드의 내용을 자세히 살펴보겠습니다.

• tokens_a: 첫 번째 입력 시퀀스로 사용되는 토큰들의 리스트입니다.
• tokens_b: 두 번째 입력 시퀀스로 사용되는 토큰들의 리스트입니다.
• encoded_pair: get_bert_encoding 함수를 호출하여 두 개의 입력 시퀀스를 BERT 모델을 통해 인코딩한 결과입니다.

위의 코드는 다음과 같은 작업을 수행합니다:

1. get_bert_encoding 함수를 호출하여 두 개의 입력 시퀀스 tokens_a와 tokens_b를 BERT 모델을 통해 함께 인코딩한 결과를 encoded_pair로 받습니다.
2. encoded_pair는 3차원 텐서입니다. 첫 번째 차원은 배치 차원, 두 번째 차원은 토큰 시퀀스의 위치 (토큰의 위치), 세 번째 차원은 BERT 모델의 히든 상태의 차원입니다.
3. encoded_pair_cls는 인코딩된 페어의 첫 번째 토큰인 <cls>의 히든 상태를 추출합니다.
4. encoded_pair_crane은 인코딩된 페어에서 "crane" 토큰의 히든 상태를 추출합니다.
5. 마지막으로, encoded_pair의 모양, encoded_pair_cls의 모양, 그리고 encoded_pair_crane의 처음 세 원소를 출력합니다.

이 코드를 실행하면 두 개의 입력 시퀀스를 BERT 모델을 통해 함께 인코딩한 결과와 해당 결과의 특정 위치에서 추출한 히든 상태를 확인할 수 있습니다

(torch.Size([1, 10, 128]),
 torch.Size([1, 128]),
 tensor([0.0430, 1.6132, 0.0437], device='cuda:0', grad_fn=<SliceBackward0>))

 

In Section 16, we will fine-tune a pretrained BERT model for downstream natural language processing applications.

 

섹션 16에서는 다운스트림 자연어 처리 애플리케이션을 위해 사전 훈련된 BERT 모델을 미세 조정합니다.

 

15.10.3. Summary

• The original BERT has two versions, where the base model has 110 million parameters and the large model has 340 million parameters.
  
  원래 BERT에는 두 가지 버전이 있습니다. 기본 모델에는 1억 1천만 개의 매개변수가 있고 대형 모델에는 3억 4천만 개의 매개변수가 있습니다.
  
  
• After pretraining BERT, we can use it to represent single text, text pairs, or any token in them.
  
  BERT를 사전 훈련한 후 이를 사용하여 단일 텍스트, 텍스트 쌍 또는 그 안에 있는 모든 토큰을 나타낼 수 있습니다.
  
  
• In the experiment, the same token has different BERT representation when their contexts are different. This supports that BERT representations are context-sensitive.
  
  실험에서 동일한 토큰은 컨텍스트가 다를 때 BERT 표현이 다릅니다. 이는 BERT 표현이 상황에 따라 달라지는 것을 지원합니다.

 

15.10.4. Exercises

1. In the experiment, we can see that the masked language modeling loss is significantly higher than the next sentence prediction loss. Why?
2. Set the maximum length of a BERT input sequence to be 512 (same as the original BERT model). Use the configurations of the original BERT model such as BERTLARGE. Do you encounter any error when running this section? Why?