 TensorFlow.org에서보기 |  Google Colab에서 실행 |  GitHub에서 소스보기 |  노트북 다운로드 |
이 가이드에서는 Transformer 모델 을 학습시켜 포르투갈어를 영어로 번역합니다. 이것은 텍스트 생성 및 주의에 대한 지식을 가정하는 고급 예제입니다.
Transformer 모델의 핵심 아이디어는 입력 시퀀스의 다른 위치에 주의를 기울여 해당 시퀀스의 표현을 계산하는 능력입니다. Transformer는 자기주의 레이어 스택을 생성하며 아래의 Scaled dot product Attention 및 Multi-head Attention 섹션에서 설명합니다.
대신에 자기 관심 층의 스택을 사용하여 변압기 모델 핸들 변수 크기의 입력 RNNs 또는 CNNs를 . 이 일반 아키텍처에는 다음과 같은 여러 장점이 있습니다.
- 데이터 전체의 시간적 / 공간적 관계에 대한 가정을하지 않습니다. 이것은 일련의 개체 (예 : StarCraft 유닛 )를 처리하는 데 이상적입니다.
- 레이어 출력은 RNN과 같은 시리즈 대신 병렬로 계산할 수 있습니다.
- 멀리있는 항목은 많은 RNN 단계 또는 컨볼 루션 레이어를 통과하지 않고도 서로의 출력에 영향을 줄 수 있습니다 (예를 들어 Scene Memory Transformer 참조).
- 장거리 의존성을 배울 수 있습니다. 이것은 많은 시퀀스 작업의 도전입니다.
이 아키텍처의 단점은 다음과 같습니다.
- 시계열의 경우 시간 단계에 대한 출력은 입력과 현재 숨겨진 상태 만이 아닌 전체 기록 에서 계산됩니다. 이것은 덜 효율적일 수 있습니다.
- 입력이 시간적 / 공간적 관계, 텍스트와 같은 일부 위치 부호화 추가해야 경우가 있는가 또는 모델 효과적으로 단어의 가방을 볼 것이다.
이 노트북에서 모델을 학습 한 후 포르투갈어 문장을 입력하고 영어 번역을 반환 할 수 있습니다.
pip install -q tfds-nightly
WARNING: You are using pip version 20.2.2; however, version 20.2.3 is available. You should consider upgrading via the '/tmpfs/src/tf_docs_env/bin/python -m pip install --upgrade pip' command.
import tensorflow_datasets as tfds
import tensorflow as tf
import time
import numpy as np
import matplotlib.pyplot as plt
입력 파이프 라인 설정
TFDS 를 사용하여 TED Talks Open Translation Project 에서 포르투갈어-영어 번역 데이터 셋 을로드합니다.
이 데이터 세트에는 약 50000 개의 교육 예제, 1100 개의 검증 예제 및 2000 개의 테스트 예제가 포함되어 있습니다.
examples, metadata = tfds.load('ted_hrlr_translate/pt_to_en', with_info=True,
as_supervised=True)
train_examples, val_examples = examples['train'], examples['validation']
Downloading and preparing dataset ted_hrlr_translate/pt_to_en/1.0.0 (download: 124.94 MiB, generated: Unknown size, total: 124.94 MiB) to /home/kbuilder/tensorflow_datasets/ted_hrlr_translate/pt_to_en/1.0.0... Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/ted_hrlr_translate/pt_to_en/1.0.0.incompleteDDYXSP/ted_hrlr_translate-train.tfrecord Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/ted_hrlr_translate/pt_to_en/1.0.0.incompleteDDYXSP/ted_hrlr_translate-validation.tfrecord Shuffling and writing examples to /home/kbuilder/tensorflow_datasets/ted_hrlr_translate/pt_to_en/1.0.0.incompleteDDYXSP/ted_hrlr_translate-test.tfrecord Dataset ted_hrlr_translate downloaded and prepared to /home/kbuilder/tensorflow_datasets/ted_hrlr_translate/pt_to_en/1.0.0. Subsequent calls will reuse this data.
훈련 데이터 세트에서 사용자 지정 하위 단어 토크 나이저를 만듭니다.
tokenizer_en = tfds.deprecated.text.SubwordTextEncoder.build_from_corpus(
(en.numpy() for pt, en in train_examples), target_vocab_size=2**13)
tokenizer_pt = tfds.deprecated.text.SubwordTextEncoder.build_from_corpus(
(pt.numpy() for pt, en in train_examples), target_vocab_size=2**13)
sample_string = 'Transformer is awesome.'
tokenized_string = tokenizer_en.encode(sample_string)
print ('Tokenized string is {}'.format(tokenized_string))
original_string = tokenizer_en.decode(tokenized_string)
print ('The original string: {}'.format(original_string))
assert original_string == sample_string
Tokenized string is [7915, 1248, 7946, 7194, 13, 2799, 7877] The original string: Transformer is awesome.
토크 나이 저는 단어가 사전에없는 경우 문자열을 하위 단어로 분할하여 문자열을 인코딩합니다.
for ts in tokenized_string:
print ('{} ----> {}'.format(ts, tokenizer_en.decode([ts])))
7915 ----> T 1248 ----> ran 7946 ----> s 7194 ----> former 13 ----> is 2799 ----> awesome 7877 ----> .
BUFFER_SIZE = 20000
BATCH_SIZE = 64
입력 및 대상에 시작 및 종료 토큰을 추가하십시오.
def encode(lang1, lang2):
lang1 = [tokenizer_pt.vocab_size] + tokenizer_pt.encode(
lang1.numpy()) + [tokenizer_pt.vocab_size+1]
lang2 = [tokenizer_en.vocab_size] + tokenizer_en.encode(
lang2.numpy()) + [tokenizer_en.vocab_size+1]
return lang1, lang2
Dataset.map 을 사용 Dataset.map 함수를 데이터 세트의 각 요소에 적용하려고합니다. Dataset.map 은 그래프 모드에서 실행됩니다.
- 그래프 텐서는 값이 없습니다.
- 그래프 모드에서는 TensorFlow Ops 및 함수 만 사용할 수 있습니다.
따라서이 함수를 직접 .map 할 수 없습니다. tf.py_function 으로 래핑해야합니다. tf.py_function 은 래핑 된 파이썬 함수에 일반 텐서 (값 및 .numpy() 메서드에 액세스)를 전달합니다.
def tf_encode(pt, en):
result_pt, result_en = tf.py_function(encode, [pt, en], [tf.int64, tf.int64])
result_pt.set_shape([None])
result_en.set_shape([None])
return result_pt, result_en
MAX_LENGTH = 40
def filter_max_length(x, y, max_length=MAX_LENGTH):
return tf.logical_and(tf.size(x) <= max_length,
tf.size(y) <= max_length)
train_dataset = train_examples.map(tf_encode)
train_dataset = train_dataset.filter(filter_max_length)
# cache the dataset to memory to get a speedup while reading from it.
train_dataset = train_dataset.cache()
train_dataset = train_dataset.shuffle(BUFFER_SIZE).padded_batch(BATCH_SIZE)
train_dataset = train_dataset.prefetch(tf.data.experimental.AUTOTUNE)
val_dataset = val_examples.map(tf_encode)
val_dataset = val_dataset.filter(filter_max_length).padded_batch(BATCH_SIZE)
pt_batch, en_batch = next(iter(val_dataset))
pt_batch, en_batch
(<tf.Tensor: shape=(64, 38), dtype=int64, numpy=
array([[8214, 342, 3032, ..., 0, 0, 0],
[8214, 95, 198, ..., 0, 0, 0],
[8214, 4479, 7990, ..., 0, 0, 0],
...,
[8214, 584, 12, ..., 0, 0, 0],
[8214, 59, 1548, ..., 0, 0, 0],
[8214, 118, 34, ..., 0, 0, 0]])>,
<tf.Tensor: shape=(64, 40), dtype=int64, numpy=
array([[8087, 98, 25, ..., 0, 0, 0],
[8087, 12, 20, ..., 0, 0, 0],
[8087, 12, 5453, ..., 0, 0, 0],
...,
[8087, 18, 2059, ..., 0, 0, 0],
[8087, 16, 1436, ..., 0, 0, 0],
[8087, 15, 57, ..., 0, 0, 0]])>)
위치 인코딩
이 모델에는 반복 또는 컨볼 루션이 포함되어 있지 않으므로 위치 인코딩이 추가되어 문장에서 단어의 상대적 위치에 대한 정보를 모델에 제공합니다.
위치 인코딩 벡터가 임베딩 벡터에 추가됩니다. 임베딩은 비슷한 의미의 토큰이 서로 더 가까워지는 d 차원 공간의 토큰을 나타냅니다. 그러나 임베딩은 문장에서 단어의 상대적 위치를 인코딩하지 않습니다. 따라서 위치 인코딩을 추가하면 단어 의 의미와 문장에서의 위치 , d 차원 공간의 유사성에 따라 단어가 서로 더 가까워집니다.
자세한 내용은 위치 인코딩 에 대한 노트북을 참조하십시오. 위치 인코딩을 계산하는 공식은 다음과 같습니다.
$$\Large{PE_{(pos, 2i)} = sin(pos / 10000^{2i / d_{model} })} $$
$$\Large{PE_{(pos, 2i+1)} = cos(pos / 10000^{2i / d_{model} })} $$
def get_angles(pos, i, d_model):
angle_rates = 1 / np.power(10000, (2 * (i//2)) / np.float32(d_model))
return pos * angle_rates
def positional_encoding(position, d_model):
angle_rads = get_angles(np.arange(position)[:, np.newaxis],
np.arange(d_model)[np.newaxis, :],
d_model)
# apply sin to even indices in the array; 2i
angle_rads[:, 0::2] = np.sin(angle_rads[:, 0::2])
# apply cos to odd indices in the array; 2i+1
angle_rads[:, 1::2] = np.cos(angle_rads[:, 1::2])
pos_encoding = angle_rads[np.newaxis, ...]
return tf.cast(pos_encoding, dtype=tf.float32)
pos_encoding = positional_encoding(50, 512)
print (pos_encoding.shape)
plt.pcolormesh(pos_encoding[0], cmap='RdBu')
plt.xlabel('Depth')
plt.xlim((0, 512))
plt.ylabel('Position')
plt.colorbar()
plt.show()
(1, 50, 512)
마스킹
시퀀스 배치의 모든 패드 토큰을 마스킹합니다. 모델이 패딩을 입력으로 취급하지 않도록합니다. 마스크는 패드 값 0 이있는 위치를 나타냅니다. 해당 위치에 1 을 출력하고 그렇지 않으면 0 출력합니다.
def create_padding_mask(seq):
seq = tf.cast(tf.math.equal(seq, 0), tf.float32)
# add extra dimensions to add the padding
# to the attention logits.
return seq[:, tf.newaxis, tf.newaxis, :] # (batch_size, 1, 1, seq_len)
x = tf.constant([[7, 6, 0, 0, 1], [1, 2, 3, 0, 0], [0, 0, 0, 4, 5]])
create_padding_mask(x)
<tf.Tensor: shape=(3, 1, 1, 5), dtype=float32, numpy=
array([[[[0., 0., 1., 1., 0.]]],
[[[0., 0., 0., 1., 1.]]],
[[[1., 1., 1., 0., 0.]]]], dtype=float32)>
미리보기 마스크는 시퀀스에서 미래 토큰을 마스킹하는 데 사용됩니다. 즉, 마스크는 사용해서는 안되는 항목을 나타냅니다.
즉, 세 번째 단어를 예측하려면 첫 번째 단어와 두 번째 단어 만 사용됩니다. 네 번째 단어를 예측하는 것과 유사하게 첫 번째, 두 번째 및 세 번째 단어 만 사용됩니다.
def create_look_ahead_mask(size):
mask = 1 - tf.linalg.band_part(tf.ones((size, size)), -1, 0)
return mask # (seq_len, seq_len)
x = tf.random.uniform((1, 3))
temp = create_look_ahead_mask(x.shape[1])
temp
<tf.Tensor: shape=(3, 3), dtype=float32, numpy=
array([[0., 1., 1.],
[0., 0., 1.],
[0., 0., 0.]], dtype=float32)>
배율 내적주의
변환기가 사용하는주의 함수는 Q (쿼리), K (키), V (값)의 세 가지 입력을받습니다. 주의 가중치를 계산하는 데 사용되는 방정식은 다음과 같습니다.
$$\Large{Attention(Q, K, V) = softmax_k(\frac{QK^T}{\sqrt{d_k} }) V} $$
내적 관심도는 깊이의 제곱근 계수로 조정됩니다. 이는 깊이 값이 크면 내적이 커지므로 기울기가 작은 소프트 맥스 함수를 밀어서 매우 딱딱한 소프트 맥스가됩니다.
예를 들어 Q 와 K 의 평균이 0이고 분산이 1이라고 가정합니다. 행렬 곱셈은 평균이 0이고 분산이 dk 입니다. 따라서 Q 와 K 의 matmul은 평균이 0이고 분산이 1이어야하고 더 부드러운 소프트 맥스를 얻으므로 dk 제곱근이 스케일링에 사용됩니다 (다른 숫자가 아님).
마스크에는 -1e9 (음의 무한대에 가까움)가 곱해집니다. 이것은 마스크가 Q와 K의 스케일 된 행렬 곱셈으로 합산되고 소프트 맥스 직전에 적용되기 때문에 수행됩니다. 목표는 이러한 셀을 제로화하는 것이며 소프트 맥스에 대한 큰 음의 입력은 출력에서 거의 0에 가깝습니다.
def scaled_dot_product_attention(q, k, v, mask):
"""Calculate the attention weights.
q, k, v must have matching leading dimensions.
k, v must have matching penultimate dimension, i.e.: seq_len_k = seq_len_v.
The mask has different shapes depending on its type(padding or look ahead)
but it must be broadcastable for addition.
Args:
q: query shape == (..., seq_len_q, depth)
k: key shape == (..., seq_len_k, depth)
v: value shape == (..., seq_len_v, depth_v)
mask: Float tensor with shape broadcastable
to (..., seq_len_q, seq_len_k). Defaults to None.
Returns:
output, attention_weights
"""
matmul_qk = tf.matmul(q, k, transpose_b=True) # (..., seq_len_q, seq_len_k)
# scale matmul_qk
dk = tf.cast(tf.shape(k)[-1], tf.float32)
scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)
# add the mask to the scaled tensor.
if mask is not None:
scaled_attention_logits += (mask * -1e9)
# softmax is normalized on the last axis (seq_len_k) so that the scores
# add up to 1.
attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1) # (..., seq_len_q, seq_len_k)
output = tf.matmul(attention_weights, v) # (..., seq_len_q, depth_v)
return output, attention_weights
소프트 맥스 정규화가 K에서 수행되므로 해당 값은 Q에 부여되는 중요도를 결정합니다.
출력은주의 가중치와 V (값) 벡터의 곱셈을 나타냅니다. 이렇게하면 집중하려는 단어가 그대로 유지되고 관련없는 단어는 제거됩니다.
def print_out(q, k, v):
temp_out, temp_attn = scaled_dot_product_attention(
q, k, v, None)
print ('Attention weights are:')
print (temp_attn)
print ('Output is:')
print (temp_out)
np.set_printoptions(suppress=True)
temp_k = tf.constant([[10,0,0],
[0,10,0],
[0,0,10],
[0,0,10]], dtype=tf.float32) # (4, 3)
temp_v = tf.constant([[ 1,0],
[ 10,0],
[ 100,5],
[1000,6]], dtype=tf.float32) # (4, 2)
# This `query` aligns with the second `key`,
# so the second `value` is returned.
temp_q = tf.constant([[0, 10, 0]], dtype=tf.float32) # (1, 3)
print_out(temp_q, temp_k, temp_v)
Attention weights are: tf.Tensor([[0. 1. 0. 0.]], shape=(1, 4), dtype=float32) Output is: tf.Tensor([[10. 0.]], shape=(1, 2), dtype=float32)
# This query aligns with a repeated key (third and fourth),
# so all associated values get averaged.
temp_q = tf.constant([[0, 0, 10]], dtype=tf.float32) # (1, 3)
print_out(temp_q, temp_k, temp_v)
Attention weights are: tf.Tensor([[0. 0. 0.5 0.5]], shape=(1, 4), dtype=float32) Output is: tf.Tensor([[550. 5.5]], shape=(1, 2), dtype=float32)
# This query aligns equally with the first and second key,
# so their values get averaged.
temp_q = tf.constant([[10, 10, 0]], dtype=tf.float32) # (1, 3)
print_out(temp_q, temp_k, temp_v)
Attention weights are: tf.Tensor([[0.5 0.5 0. 0. ]], shape=(1, 4), dtype=float32) Output is: tf.Tensor([[5.5 0. ]], shape=(1, 2), dtype=float32)
모든 쿼리를 함께 전달하십시오.
temp_q = tf.constant([[0, 0, 10], [0, 10, 0], [10, 10, 0]], dtype=tf.float32) # (3, 3)
print_out(temp_q, temp_k, temp_v)
Attention weights are: tf.Tensor( [[0. 0. 0.5 0.5] [0. 1. 0. 0. ] [0.5 0.5 0. 0. ]], shape=(3, 4), dtype=float32) Output is: tf.Tensor( [[550. 5.5] [ 10. 0. ] [ 5.5 0. ]], shape=(3, 2), dtype=float32)
다중 머리주의
다중 머리주의는 네 부분으로 구성됩니다.
- 선형 레이어 및 헤드로 분할됩니다.
- 확장 된 내적주의.
- 머리의 연결.
- 최종 선형 레이어.
각 다중 헤드주의 블록에는 세 가지 입력이 있습니다. Q (쿼리), K (키), V (값). 이들은 선형 (Dense) 레이어를 통과하여 여러 개의 헤드로 분할됩니다.
위에서 정의한 scaled_dot_product_attention 은 각 헤드에 적용됩니다 (효율성을 위해 방송 됨). 주의 단계에서 적절한 마스크를 사용해야합니다. 그런 다음 각 헤드에 대한 어텐션 출력이 연결되고 ( tf.transpose 및 tf.reshape ) 최종 Dense 레이어를 통과합니다.
하나의 어텐션 헤드 대신 Q, K, V는 모델이 서로 다른 표현 공간의 서로 다른 위치에있는 정보에 공동으로 참여할 수 있기 때문에 여러 개의 헤드로 분할됩니다. 분할 후 각 머리는 차원이 감소하므로 총 계산 비용은 전체 차원의 단일 머리주의와 동일합니다.
class MultiHeadAttention(tf.keras.layers.Layer):
def __init__(self, d_model, num_heads):
super(MultiHeadAttention, self).__init__()
self.num_heads = num_heads
self.d_model = d_model
assert d_model % self.num_heads == 0
self.depth = d_model // self.num_heads
self.wq = tf.keras.layers.Dense(d_model)
self.wk = tf.keras.layers.Dense(d_model)
self.wv = tf.keras.layers.Dense(d_model)
self.dense = tf.keras.layers.Dense(d_model)
def split_heads(self, x, batch_size):
"""Split the last dimension into (num_heads, depth).
Transpose the result such that the shape is (batch_size, num_heads, seq_len, depth)
"""
x = tf.reshape(x, (batch_size, -1, self.num_heads, self.depth))
return tf.transpose(x, perm=[0, 2, 1, 3])
def call(self, v, k, q, mask):
batch_size = tf.shape(q)[0]
q = self.wq(q) # (batch_size, seq_len, d_model)
k = self.wk(k) # (batch_size, seq_len, d_model)
v = self.wv(v) # (batch_size, seq_len, d_model)
q = self.split_heads(q, batch_size) # (batch_size, num_heads, seq_len_q, depth)
k = self.split_heads(k, batch_size) # (batch_size, num_heads, seq_len_k, depth)
v = self.split_heads(v, batch_size) # (batch_size, num_heads, seq_len_v, depth)
# scaled_attention.shape == (batch_size, num_heads, seq_len_q, depth)
# attention_weights.shape == (batch_size, num_heads, seq_len_q, seq_len_k)
scaled_attention, attention_weights = scaled_dot_product_attention(
q, k, v, mask)
scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3]) # (batch_size, seq_len_q, num_heads, depth)
concat_attention = tf.reshape(scaled_attention,
(batch_size, -1, self.d_model)) # (batch_size, seq_len_q, d_model)
output = self.dense(concat_attention) # (batch_size, seq_len_q, d_model)
return output, attention_weights
시도 할 MultiHeadAttention 레이어를 만듭니다. 시퀀스의 각 위치 y 에서 MultiHeadAttention 은 시퀀스의 다른 모든 위치에서 8 개의주의 헤드를 모두 실행하여 각 위치에서 동일한 길이의 새 벡터를 반환합니다.
temp_mha = MultiHeadAttention(d_model=512, num_heads=8)
y = tf.random.uniform((1, 60, 512)) # (batch_size, encoder_sequence, d_model)
out, attn = temp_mha(y, k=y, q=y, mask=None)
out.shape, attn.shape
(TensorShape([1, 60, 512]), TensorShape([1, 8, 60, 60]))
포인트 현명한 피드 포워드 네트워크
포인트 현명한 피드 포워드 네트워크는 ReLU 활성화가 중간에있는 두 개의 완전히 연결된 계층으로 구성됩니다.
def point_wise_feed_forward_network(d_model, dff):
return tf.keras.Sequential([
tf.keras.layers.Dense(dff, activation='relu'), # (batch_size, seq_len, dff)
tf.keras.layers.Dense(d_model) # (batch_size, seq_len, d_model)
])
sample_ffn = point_wise_feed_forward_network(512, 2048)
sample_ffn(tf.random.uniform((64, 50, 512))).shape
TensorShape([64, 50, 512])
인코더 및 디코더
변환기 모델 은주의 모델로 시퀀싱하기 위해 표준 시퀀스 와 동일한 일반 패턴을 따릅니다.
- 입력 문장은 시퀀스의 각 단어 / 토큰에 대한 출력을 생성하는
N인코더 레이어를 통해 전달됩니다. - 디코더는 다음 단어를 예측하기 위해 인코더의 출력과 자체 입력 (자기주의)을 처리합니다.
인코더 레이어
각 인코더 계층은 하위 계층으로 구성됩니다.
- 다중 머리주의 (패딩 마스크 포함)
- 포인트 현명한 피드 포워드 네트워크.
이러한 각 하위 계층에는 계층 정규화가 뒤 따르는 잔여 연결이 있습니다. 잔여 연결은 심층 네트워크에서 그라디언트가 사라지는 문제를 방지하는 데 도움이됩니다.
각 하위 계층의 출력은 LayerNorm(x + Sublayer(x)) 입니다. 정규화는 d_model (마지막) 축에서 수행됩니다. 변압기에는 N 개의 인코더 레이어가 있습니다.
class EncoderLayer(tf.keras.layers.Layer):
def __init__(self, d_model, num_heads, dff, rate=0.1):
super(EncoderLayer, self).__init__()
self.mha = MultiHeadAttention(d_model, num_heads)
self.ffn = point_wise_feed_forward_network(d_model, dff)
self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
self.dropout1 = tf.keras.layers.Dropout(rate)
self.dropout2 = tf.keras.layers.Dropout(rate)
def call(self, x, training, mask):
attn_output, _ = self.mha(x, x, x, mask) # (batch_size, input_seq_len, d_model)
attn_output = self.dropout1(attn_output, training=training)
out1 = self.layernorm1(x + attn_output) # (batch_size, input_seq_len, d_model)
ffn_output = self.ffn(out1) # (batch_size, input_seq_len, d_model)
ffn_output = self.dropout2(ffn_output, training=training)
out2 = self.layernorm2(out1 + ffn_output) # (batch_size, input_seq_len, d_model)
return out2
sample_encoder_layer = EncoderLayer(512, 8, 2048)
sample_encoder_layer_output = sample_encoder_layer(
tf.random.uniform((64, 43, 512)), False, None)
sample_encoder_layer_output.shape # (batch_size, input_seq_len, d_model)
TensorShape([64, 43, 512])
디코더 레이어
각 디코더 계층은 하위 계층으로 구성됩니다.
- 마스킹 된 멀티 헤드주의 (미리보기 마스크 및 패딩 마스크 포함)
- 다중 머리주의 (패딩 마스크 포함). V (값) 및 K (키)는 엔코더 출력 을 입력으로받습니다. Q (쿼리)는 마스킹 된 다중 머리주의 하위 계층에서 출력을 수신합니다 .
- 포인트 현명한 피드 포워드 네트워크
이러한 각 하위 계층에는 계층 정규화가 뒤 따르는 잔여 연결이 있습니다. 각 하위 계층의 출력은 LayerNorm(x + Sublayer(x)) 입니다. 정규화는 d_model (마지막) 축에서 수행됩니다.
트랜스포머에는 N 개의 디코더 레이어가 있습니다.
Q가 디코더의 첫 번째주의 블록에서 출력을 수신하고 K가 인코더 출력을 수신 할 때주의 가중치는 인코더의 출력을 기반으로 디코더의 입력에 주어진 중요도를 나타냅니다. 즉, 디코더는 인코더 출력을보고 자체 출력에 자동으로 참석하여 다음 단어를 예측합니다. 스케일 된 내적주의 섹션에서 위의 데모를 참조하십시오.
class DecoderLayer(tf.keras.layers.Layer):
def __init__(self, d_model, num_heads, dff, rate=0.1):
super(DecoderLayer, self).__init__()
self.mha1 = MultiHeadAttention(d_model, num_heads)
self.mha2 = MultiHeadAttention(d_model, num_heads)
self.ffn = point_wise_feed_forward_network(d_model, dff)
self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
self.layernorm3 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
self.dropout1 = tf.keras.layers.Dropout(rate)
self.dropout2 = tf.keras.layers.Dropout(rate)
self.dropout3 = tf.keras.layers.Dropout(rate)
def call(self, x, enc_output, training,
look_ahead_mask, padding_mask):
# enc_output.shape == (batch_size, input_seq_len, d_model)
attn1, attn_weights_block1 = self.mha1(x, x, x, look_ahead_mask) # (batch_size, target_seq_len, d_model)
attn1 = self.dropout1(attn1, training=training)
out1 = self.layernorm1(attn1 + x)
attn2, attn_weights_block2 = self.mha2(
enc_output, enc_output, out1, padding_mask) # (batch_size, target_seq_len, d_model)
attn2 = self.dropout2(attn2, training=training)
out2 = self.layernorm2(attn2 + out1) # (batch_size, target_seq_len, d_model)
ffn_output = self.ffn(out2) # (batch_size, target_seq_len, d_model)
ffn_output = self.dropout3(ffn_output, training=training)
out3 = self.layernorm3(ffn_output + out2) # (batch_size, target_seq_len, d_model)
return out3, attn_weights_block1, attn_weights_block2
sample_decoder_layer = DecoderLayer(512, 8, 2048)
sample_decoder_layer_output, _, _ = sample_decoder_layer(
tf.random.uniform((64, 50, 512)), sample_encoder_layer_output,
False, None, None)
sample_decoder_layer_output.shape # (batch_size, target_seq_len, d_model)
TensorShape([64, 50, 512])
인코더
Encoder 는 다음으로 구성됩니다.
- 입력 임베딩
- 위치 인코딩
- N 인코더 레이어
입력은 위치 인코딩과 합산되는 임베딩을 통해 이루어집니다. 이 합산의 출력은 인코더 계층에 대한 입력입니다. 인코더의 출력은 디코더에 대한 입력입니다.
class Encoder(tf.keras.layers.Layer):
def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size,
maximum_position_encoding, rate=0.1):
super(Encoder, self).__init__()
self.d_model = d_model
self.num_layers = num_layers
self.embedding = tf.keras.layers.Embedding(input_vocab_size, d_model)
self.pos_encoding = positional_encoding(maximum_position_encoding,
self.d_model)
self.enc_layers = [EncoderLayer(d_model, num_heads, dff, rate)
for _ in range(num_layers)]
self.dropout = tf.keras.layers.Dropout(rate)
def call(self, x, training, mask):
seq_len = tf.shape(x)[1]
# adding embedding and position encoding.
x = self.embedding(x) # (batch_size, input_seq_len, d_model)
x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))
x += self.pos_encoding[:, :seq_len, :]
x = self.dropout(x, training=training)
for i in range(self.num_layers):
x = self.enc_layers[i](x, training, mask)
return x # (batch_size, input_seq_len, d_model)
sample_encoder = Encoder(num_layers=2, d_model=512, num_heads=8,
dff=2048, input_vocab_size=8500,
maximum_position_encoding=10000)
temp_input = tf.random.uniform((64, 62), dtype=tf.int64, minval=0, maxval=200)
sample_encoder_output = sample_encoder(temp_input, training=False, mask=None)
print (sample_encoder_output.shape) # (batch_size, input_seq_len, d_model)
(64, 62, 512)
디코더
Decoder 는 다음으로 구성됩니다.
- 출력 임베딩
- 위치 인코딩
- N 디코더 레이어
대상은 위치 인코딩으로 합산되는 임베딩을 통과합니다. 이 합산의 출력은 디코더 계층에 대한 입력입니다. 디코더의 출력은 최종 선형 레이어에 대한 입력입니다.
class Decoder(tf.keras.layers.Layer):
def __init__(self, num_layers, d_model, num_heads, dff, target_vocab_size,
maximum_position_encoding, rate=0.1):
super(Decoder, self).__init__()
self.d_model = d_model
self.num_layers = num_layers
self.embedding = tf.keras.layers.Embedding(target_vocab_size, d_model)
self.pos_encoding = positional_encoding(maximum_position_encoding, d_model)
self.dec_layers = [DecoderLayer(d_model, num_heads, dff, rate)
for _ in range(num_layers)]
self.dropout = tf.keras.layers.Dropout(rate)
def call(self, x, enc_output, training,
look_ahead_mask, padding_mask):
seq_len = tf.shape(x)[1]
attention_weights = {}
x = self.embedding(x) # (batch_size, target_seq_len, d_model)
x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))
x += self.pos_encoding[:, :seq_len, :]
x = self.dropout(x, training=training)
for i in range(self.num_layers):
x, block1, block2 = self.dec_layers[i](x, enc_output, training,
look_ahead_mask, padding_mask)
attention_weights['decoder_layer{}_block1'.format(i+1)] = block1
attention_weights['decoder_layer{}_block2'.format(i+1)] = block2
# x.shape == (batch_size, target_seq_len, d_model)
return x, attention_weights
sample_decoder = Decoder(num_layers=2, d_model=512, num_heads=8,
dff=2048, target_vocab_size=8000,
maximum_position_encoding=5000)
temp_input = tf.random.uniform((64, 26), dtype=tf.int64, minval=0, maxval=200)
output, attn = sample_decoder(temp_input,
enc_output=sample_encoder_output,
training=False,
look_ahead_mask=None,
padding_mask=None)
output.shape, attn['decoder_layer2_block2'].shape
(TensorShape([64, 26, 512]), TensorShape([64, 8, 26, 62]))
변환기 만들기
Transformer는 인코더, 디코더 및 최종 선형 레이어로 구성됩니다. 디코더의 출력은 선형 레이어에 대한 입력이며 출력이 반환됩니다.
class Transformer(tf.keras.Model):
def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size,
target_vocab_size, pe_input, pe_target, rate=0.1):
super(Transformer, self).__init__()
self.encoder = Encoder(num_layers, d_model, num_heads, dff,
input_vocab_size, pe_input, rate)
self.decoder = Decoder(num_layers, d_model, num_heads, dff,
target_vocab_size, pe_target, rate)
self.final_layer = tf.keras.layers.Dense(target_vocab_size)
def call(self, inp, tar, training, enc_padding_mask,
look_ahead_mask, dec_padding_mask):
enc_output = self.encoder(inp, training, enc_padding_mask) # (batch_size, inp_seq_len, d_model)
# dec_output.shape == (batch_size, tar_seq_len, d_model)
dec_output, attention_weights = self.decoder(
tar, enc_output, training, look_ahead_mask, dec_padding_mask)
final_output = self.final_layer(dec_output) # (batch_size, tar_seq_len, target_vocab_size)
return final_output, attention_weights
sample_transformer = Transformer(
num_layers=2, d_model=512, num_heads=8, dff=2048,
input_vocab_size=8500, target_vocab_size=8000,
pe_input=10000, pe_target=6000)
temp_input = tf.random.uniform((64, 38), dtype=tf.int64, minval=0, maxval=200)
temp_target = tf.random.uniform((64, 36), dtype=tf.int64, minval=0, maxval=200)
fn_out, _ = sample_transformer(temp_input, temp_target, training=False,
enc_padding_mask=None,
look_ahead_mask=None,
dec_padding_mask=None)
fn_out.shape # (batch_size, tar_seq_len, target_vocab_size)
TensorShape([64, 36, 8000])
초 매개 변수 설정
이 예제를 작고 상대적으로 빠르게 유지하기 위해 num_layers, d_model 및 dff 의 값을 줄였습니다.
변압기의 기본 모델에 사용 된 값은 다음과 같습니다. num_layers = 6 , d_model = 512 , dff = 2048 . 다른 모든 버전의 변압기에 대한 문서 를 참조하십시오.
num_layers = 4
d_model = 128
dff = 512
num_heads = 8
input_vocab_size = tokenizer_pt.vocab_size + 2
target_vocab_size = tokenizer_en.vocab_size + 2
dropout_rate = 0.1
옵티 마이저
논문 의 공식에 따라 맞춤 학습률 스케줄러와 함께 Adam 최적화 프로그램을 사용합니다.
$$\Large{lrate = d_{model}^{-0.5} * min(step{\_}num^{-0.5}, step{\_}num * warmup{\_}steps^{-1.5})}$$
class CustomSchedule(tf.keras.optimizers.schedules.LearningRateSchedule):
def __init__(self, d_model, warmup_steps=4000):
super(CustomSchedule, self).__init__()
self.d_model = d_model
self.d_model = tf.cast(self.d_model, tf.float32)
self.warmup_steps = warmup_steps
def __call__(self, step):
arg1 = tf.math.rsqrt(step)
arg2 = step * (self.warmup_steps ** -1.5)
return tf.math.rsqrt(self.d_model) * tf.math.minimum(arg1, arg2)
learning_rate = CustomSchedule(d_model)
optimizer = tf.keras.optimizers.Adam(learning_rate, beta_1=0.9, beta_2=0.98,
epsilon=1e-9)
temp_learning_rate_schedule = CustomSchedule(d_model)
plt.plot(temp_learning_rate_schedule(tf.range(40000, dtype=tf.float32)))
plt.ylabel("Learning Rate")
plt.xlabel("Train Step")
Text(0.5, 0, 'Train Step')
손실 및 지표
타겟 시퀀스가 패딩되기 때문에 손실을 계산할 때 패딩 마스크를 적용하는 것이 중요합니다.
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(
from_logits=True, reduction='none')
def loss_function(real, pred):
mask = tf.math.logical_not(tf.math.equal(real, 0))
loss_ = loss_object(real, pred)
mask = tf.cast(mask, dtype=loss_.dtype)
loss_ *= mask
return tf.reduce_sum(loss_)/tf.reduce_sum(mask)
train_loss = tf.keras.metrics.Mean(name='train_loss')
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
name='train_accuracy')
교육 및 체크 포인트
transformer = Transformer(num_layers, d_model, num_heads, dff,
input_vocab_size, target_vocab_size,
pe_input=input_vocab_size,
pe_target=target_vocab_size,
rate=dropout_rate)
def create_masks(inp, tar):
# Encoder padding mask
enc_padding_mask = create_padding_mask(inp)
# Used in the 2nd attention block in the decoder.
# This padding mask is used to mask the encoder outputs.
dec_padding_mask = create_padding_mask(inp)
# Used in the 1st attention block in the decoder.
# It is used to pad and mask future tokens in the input received by
# the decoder.
look_ahead_mask = create_look_ahead_mask(tf.shape(tar)[1])
dec_target_padding_mask = create_padding_mask(tar)
combined_mask = tf.maximum(dec_target_padding_mask, look_ahead_mask)
return enc_padding_mask, combined_mask, dec_padding_mask
체크 포인트 경로와 체크 포인트 관리자를 생성합니다. 이는 n epoch마다 체크 포인트를 저장하는 데 사용됩니다.
checkpoint_path = "./checkpoints/train"
ckpt = tf.train.Checkpoint(transformer=transformer,
optimizer=optimizer)
ckpt_manager = tf.train.CheckpointManager(ckpt, checkpoint_path, max_to_keep=5)
# if a checkpoint exists, restore the latest checkpoint.
if ckpt_manager.latest_checkpoint:
ckpt.restore(ckpt_manager.latest_checkpoint)
print ('Latest checkpoint restored!!')
대상은 tar_inp와 tar_real로 나뉩니다. tar_inp는 디코더에 대한 입력으로 전달됩니다. tar_real 동일한 입력이 1만큼 시프트이다 : 각 위치에서 tar_input , tar_real 예측되어야하는 다음의 토큰을 포함한다.
예를 들어, sentence = "SOS 정글의 사자는 EOS를 자고 있습니다"
tar_inp = "SOS 정글의 사자가 자고 있습니다."
tar_real = "정글의 사자가 EOS를 자고 있습니다"
변환기는 자동 회귀 모델입니다. 한 번에 한 부분 씩 예측하고 지금까지의 출력을 사용하여 다음에 수행 할 작업을 결정합니다.
훈련 중에이 예제는 교사 강제를 사용합니다 ( 텍스트 생성 튜토리얼 에서와 같이). 교사 강제는 모델이 현재 시간 단계에서 무엇을 예측하는지에 관계없이 실제 출력을 다음 시간 단계로 전달합니다.
변환기가 각 단어를 예측할 때 자기주의를 통해 입력 시퀀스의 이전 단어를보고 다음 단어를 더 잘 예측할 수 있습니다.
모델이 예상 출력을 엿보는 것을 방지하기 위해 모델은 미리보기 마스크를 사용합니다.
EPOCHS = 20
# The @tf.function trace-compiles train_step into a TF graph for faster
# execution. The function specializes to the precise shape of the argument
# tensors. To avoid re-tracing due to the variable sequence lengths or variable
# batch sizes (the last batch is smaller), use input_signature to specify
# more generic shapes.
train_step_signature = [
tf.TensorSpec(shape=(None, None), dtype=tf.int64),
tf.TensorSpec(shape=(None, None), dtype=tf.int64),
]
@tf.function(input_signature=train_step_signature)
def train_step(inp, tar):
tar_inp = tar[:, :-1]
tar_real = tar[:, 1:]
enc_padding_mask, combined_mask, dec_padding_mask = create_masks(inp, tar_inp)
with tf.GradientTape() as tape:
predictions, _ = transformer(inp, tar_inp,
True,
enc_padding_mask,
combined_mask,
dec_padding_mask)
loss = loss_function(tar_real, predictions)
gradients = tape.gradient(loss, transformer.trainable_variables)
optimizer.apply_gradients(zip(gradients, transformer.trainable_variables))
train_loss(loss)
train_accuracy(tar_real, predictions)
포르투갈어가 입력 언어로 사용되며 영어가 대상 언어입니다.
for epoch in range(EPOCHS):
start = time.time()
train_loss.reset_states()
train_accuracy.reset_states()
# inp -> portuguese, tar -> english
for (batch, (inp, tar)) in enumerate(train_dataset):
train_step(inp, tar)
if batch % 50 == 0:
print ('Epoch {} Batch {} Loss {:.4f} Accuracy {:.4f}'.format(
epoch + 1, batch, train_loss.result(), train_accuracy.result()))
if (epoch + 1) % 5 == 0:
ckpt_save_path = ckpt_manager.save()
print ('Saving checkpoint for epoch {} at {}'.format(epoch+1,
ckpt_save_path))
print ('Epoch {} Loss {:.4f} Accuracy {:.4f}'.format(epoch + 1,
train_loss.result(),
train_accuracy.result()))
print ('Time taken for 1 epoch: {} secs\n'.format(time.time() - start))
Epoch 1 Batch 0 Loss 9.0005 Accuracy 0.0000 Epoch 1 Batch 50 Loss 8.9530 Accuracy 0.0007 Epoch 1 Batch 100 Loss 8.8622 Accuracy 0.0115 Epoch 1 Batch 150 Loss 8.7592 Accuracy 0.0167 Epoch 1 Batch 200 Loss 8.6354 Accuracy 0.0193 Epoch 1 Batch 250 Loss 8.4868 Accuracy 0.0216 Epoch 1 Batch 300 Loss 8.3156 Accuracy 0.0240 Epoch 1 Batch 350 Loss 8.1325 Accuracy 0.0283 Epoch 1 Batch 400 Loss 7.9531 Accuracy 0.0318 Epoch 1 Batch 450 Loss 7.7899 Accuracy 0.0348 Epoch 1 Batch 500 Loss 7.6434 Accuracy 0.0380 Epoch 1 Batch 550 Loss 7.5091 Accuracy 0.0415 Epoch 1 Batch 600 Loss 7.3815 Accuracy 0.0452 Epoch 1 Batch 650 Loss 7.2589 Accuracy 0.0487 Epoch 1 Batch 700 Loss 7.1422 Accuracy 0.0522 Epoch 1 Loss 7.1379 Accuracy 0.0523 Time taken for 1 epoch: 55.227755069732666 secs Epoch 2 Batch 0 Loss 5.5778 Accuracy 0.0921 Epoch 2 Batch 50 Loss 5.4727 Accuracy 0.1035 Epoch 2 Batch 100 Loss 5.4241 Accuracy 0.1061 Epoch 2 Batch 150 Loss 5.3629 Accuracy 0.1087 Epoch 2 Batch 200 Loss 5.3115 Accuracy 0.1104 Epoch 2 Batch 250 Loss 5.2689 Accuracy 0.1126 Epoch 2 Batch 300 Loss 5.2314 Accuracy 0.1142 Epoch 2 Batch 350 Loss 5.1934 Accuracy 0.1159 Epoch 2 Batch 400 Loss 5.1581 Accuracy 0.1177 Epoch 2 Batch 450 Loss 5.1253 Accuracy 0.1192 Epoch 2 Batch 500 Loss 5.0975 Accuracy 0.1204 Epoch 2 Batch 550 Loss 5.0690 Accuracy 0.1218 Epoch 2 Batch 600 Loss 5.0440 Accuracy 0.1229 Epoch 2 Batch 650 Loss 5.0206 Accuracy 0.1243 Epoch 2 Batch 700 Loss 4.9982 Accuracy 0.1253 Epoch 2 Loss 4.9975 Accuracy 0.1254 Time taken for 1 epoch: 29.222673654556274 secs Epoch 3 Batch 0 Loss 4.7296 Accuracy 0.1233 Epoch 3 Batch 50 Loss 4.5995 Accuracy 0.1418 Epoch 3 Batch 100 Loss 4.5976 Accuracy 0.1424 Epoch 3 Batch 150 Loss 4.5859 Accuracy 0.1431 Epoch 3 Batch 200 Loss 4.5728 Accuracy 0.1437 Epoch 3 Batch 250 Loss 4.5634 Accuracy 0.1444 Epoch 3 Batch 300 Loss 4.5507 Accuracy 0.1450 Epoch 3 Batch 350 Loss 4.5348 Accuracy 0.1464 Epoch 3 Batch 400 Loss 4.5219 Accuracy 0.1471 Epoch 3 Batch 450 Loss 4.5066 Accuracy 0.1480 Epoch 3 Batch 500 Loss 4.4918 Accuracy 0.1488 Epoch 3 Batch 550 Loss 4.4763 Accuracy 0.1497 Epoch 3 Batch 600 Loss 4.4627 Accuracy 0.1507 Epoch 3 Batch 650 Loss 4.4462 Accuracy 0.1517 Epoch 3 Batch 700 Loss 4.4327 Accuracy 0.1525 Epoch 3 Loss 4.4321 Accuracy 0.1525 Time taken for 1 epoch: 29.389445304870605 secs Epoch 4 Batch 0 Loss 4.3032 Accuracy 0.1653 Epoch 4 Batch 50 Loss 4.0700 Accuracy 0.1695 Epoch 4 Batch 100 Loss 4.0660 Accuracy 0.1691 Epoch 4 Batch 150 Loss 4.0641 Accuracy 0.1704 Epoch 4 Batch 200 Loss 4.0517 Accuracy 0.1713 Epoch 4 Batch 250 Loss 4.0392 Accuracy 0.1725 Epoch 4 Batch 300 Loss 4.0218 Accuracy 0.1738 Epoch 4 Batch 350 Loss 4.0098 Accuracy 0.1747 Epoch 4 Batch 400 Loss 3.9930 Accuracy 0.1758 Epoch 4 Batch 450 Loss 3.9805 Accuracy 0.1766 Epoch 4 Batch 500 Loss 3.9684 Accuracy 0.1779 Epoch 4 Batch 550 Loss 3.9550 Accuracy 0.1788 Epoch 4 Batch 600 Loss 3.9410 Accuracy 0.1796 Epoch 4 Batch 650 Loss 3.9266 Accuracy 0.1806 Epoch 4 Batch 700 Loss 3.9129 Accuracy 0.1815 Epoch 4 Loss 3.9129 Accuracy 0.1815 Time taken for 1 epoch: 29.373191595077515 secs Epoch 5 Batch 0 Loss 3.6592 Accuracy 0.2146 Epoch 5 Batch 50 Loss 3.5730 Accuracy 0.1983 Epoch 5 Batch 100 Loss 3.5666 Accuracy 0.2006 Epoch 5 Batch 150 Loss 3.5539 Accuracy 0.2003 Epoch 5 Batch 200 Loss 3.5464 Accuracy 0.2005 Epoch 5 Batch 250 Loss 3.5414 Accuracy 0.2011 Epoch 5 Batch 300 Loss 3.5311 Accuracy 0.2019 Epoch 5 Batch 350 Loss 3.5189 Accuracy 0.2023 Epoch 5 Batch 400 Loss 3.5088 Accuracy 0.2033 Epoch 5 Batch 450 Loss 3.4989 Accuracy 0.2044 Epoch 5 Batch 500 Loss 3.4944 Accuracy 0.2050 Epoch 5 Batch 550 Loss 3.4835 Accuracy 0.2058 Epoch 5 Batch 600 Loss 3.4762 Accuracy 0.2063 Epoch 5 Batch 650 Loss 3.4692 Accuracy 0.2069 Epoch 5 Batch 700 Loss 3.4570 Accuracy 0.2076 Saving checkpoint for epoch 5 at ./checkpoints/train/ckpt-1 Epoch 5 Loss 3.4570 Accuracy 0.2076 Time taken for 1 epoch: 29.62894082069397 secs Epoch 6 Batch 0 Loss 3.0676 Accuracy 0.2079 Epoch 6 Batch 50 Loss 3.1464 Accuracy 0.2222 Epoch 6 Batch 100 Loss 3.1415 Accuracy 0.2224 Epoch 6 Batch 150 Loss 3.1251 Accuracy 0.2233 Epoch 6 Batch 200 Loss 3.1303 Accuracy 0.2233 Epoch 6 Batch 250 Loss 3.1271 Accuracy 0.2240 Epoch 6 Batch 300 Loss 3.1222 Accuracy 0.2243 Epoch 6 Batch 350 Loss 3.1155 Accuracy 0.2245 Epoch 6 Batch 400 Loss 3.1114 Accuracy 0.2252 Epoch 6 Batch 450 Loss 3.1075 Accuracy 0.2251 Epoch 6 Batch 500 Loss 3.1011 Accuracy 0.2256 Epoch 6 Batch 550 Loss 3.0944 Accuracy 0.2256 Epoch 6 Batch 600 Loss 3.0865 Accuracy 0.2259 Epoch 6 Batch 650 Loss 3.0789 Accuracy 0.2264 Epoch 6 Batch 700 Loss 3.0734 Accuracy 0.2272 Epoch 6 Loss 3.0726 Accuracy 0.2272 Time taken for 1 epoch: 29.619795560836792 secs Epoch 7 Batch 0 Loss 2.6502 Accuracy 0.2699 Epoch 7 Batch 50 Loss 2.7479 Accuracy 0.2450 Epoch 7 Batch 100 Loss 2.7388 Accuracy 0.2455 Epoch 7 Batch 150 Loss 2.7329 Accuracy 0.2451 Epoch 7 Batch 200 Loss 2.7345 Accuracy 0.2455 Epoch 7 Batch 250 Loss 2.7379 Accuracy 0.2450 Epoch 7 Batch 300 Loss 2.7314 Accuracy 0.2457 Epoch 7 Batch 350 Loss 2.7256 Accuracy 0.2456 Epoch 7 Batch 400 Loss 2.7182 Accuracy 0.2467 Epoch 7 Batch 450 Loss 2.7106 Accuracy 0.2470 Epoch 7 Batch 500 Loss 2.7048 Accuracy 0.2477 Epoch 7 Batch 550 Loss 2.7012 Accuracy 0.2481 Epoch 7 Batch 600 Loss 2.6969 Accuracy 0.2483 Epoch 7 Batch 650 Loss 2.6922 Accuracy 0.2488 Epoch 7 Batch 700 Loss 2.6878 Accuracy 0.2494 Epoch 7 Loss 2.6879 Accuracy 0.2494 Time taken for 1 epoch: 29.344128608703613 secs Epoch 8 Batch 0 Loss 2.0878 Accuracy 0.2922 Epoch 8 Batch 50 Loss 2.3954 Accuracy 0.2664 Epoch 8 Batch 100 Loss 2.3886 Accuracy 0.2660 Epoch 8 Batch 150 Loss 2.3882 Accuracy 0.2647 Epoch 8 Batch 200 Loss 2.3828 Accuracy 0.2647 Epoch 8 Batch 250 Loss 2.3849 Accuracy 0.2643 Epoch 8 Batch 300 Loss 2.3867 Accuracy 0.2639 Epoch 8 Batch 350 Loss 2.3880 Accuracy 0.2644 Epoch 8 Batch 400 Loss 2.3824 Accuracy 0.2650 Epoch 8 Batch 450 Loss 2.3813 Accuracy 0.2644 Epoch 8 Batch 500 Loss 2.3770 Accuracy 0.2649 Epoch 8 Batch 550 Loss 2.3748 Accuracy 0.2654 Epoch 8 Batch 600 Loss 2.3735 Accuracy 0.2656 Epoch 8 Batch 650 Loss 2.3718 Accuracy 0.2657 Epoch 8 Batch 700 Loss 2.3706 Accuracy 0.2661 Epoch 8 Loss 2.3704 Accuracy 0.2661 Time taken for 1 epoch: 29.539512157440186 secs Epoch 9 Batch 0 Loss 2.3050 Accuracy 0.2683 Epoch 9 Batch 50 Loss 2.1005 Accuracy 0.2827 Epoch 9 Batch 100 Loss 2.1171 Accuracy 0.2826 Epoch 9 Batch 150 Loss 2.1191 Accuracy 0.2819 Epoch 9 Batch 200 Loss 2.1282 Accuracy 0.2807 Epoch 9 Batch 250 Loss 2.1299 Accuracy 0.2799 Epoch 9 Batch 300 Loss 2.1313 Accuracy 0.2804 Epoch 9 Batch 350 Loss 2.1334 Accuracy 0.2800 Epoch 9 Batch 400 Loss 2.1306 Accuracy 0.2803 Epoch 9 Batch 450 Loss 2.1340 Accuracy 0.2806 Epoch 9 Batch 500 Loss 2.1366 Accuracy 0.2805 Epoch 9 Batch 550 Loss 2.1365 Accuracy 0.2802 Epoch 9 Batch 600 Loss 2.1366 Accuracy 0.2802 Epoch 9 Batch 650 Loss 2.1381 Accuracy 0.2800 Epoch 9 Batch 700 Loss 2.1414 Accuracy 0.2801 Epoch 9 Loss 2.1417 Accuracy 0.2801 Time taken for 1 epoch: 29.506006717681885 secs Epoch 10 Batch 0 Loss 1.7658 Accuracy 0.3218 Epoch 10 Batch 50 Loss 1.9077 Accuracy 0.2935 Epoch 10 Batch 100 Loss 1.9111 Accuracy 0.2916 Epoch 10 Batch 150 Loss 1.9228 Accuracy 0.2912 Epoch 10 Batch 200 Loss 1.9319 Accuracy 0.2899 Epoch 10 Batch 250 Loss 1.9373 Accuracy 0.2894 Epoch 10 Batch 300 Loss 1.9431 Accuracy 0.2894 Epoch 10 Batch 350 Loss 1.9470 Accuracy 0.2897 Epoch 10 Batch 400 Loss 1.9526 Accuracy 0.2898 Epoch 10 Batch 450 Loss 1.9540 Accuracy 0.2904 Epoch 10 Batch 500 Loss 1.9562 Accuracy 0.2904 Epoch 10 Batch 550 Loss 1.9577 Accuracy 0.2905 Epoch 10 Batch 600 Loss 1.9618 Accuracy 0.2907 Epoch 10 Batch 650 Loss 1.9647 Accuracy 0.2907 Epoch 10 Batch 700 Loss 1.9671 Accuracy 0.2905 Saving checkpoint for epoch 10 at ./checkpoints/train/ckpt-2 Epoch 10 Loss 1.9671 Accuracy 0.2906 Time taken for 1 epoch: 30.555190324783325 secs Epoch 11 Batch 0 Loss 1.8220 Accuracy 0.2686 Epoch 11 Batch 50 Loss 1.7587 Accuracy 0.3028 Epoch 11 Batch 100 Loss 1.7730 Accuracy 0.3025 Epoch 11 Batch 150 Loss 1.7838 Accuracy 0.3021 Epoch 11 Batch 200 Loss 1.7953 Accuracy 0.3013 Epoch 11 Batch 250 Loss 1.7928 Accuracy 0.3009 Epoch 11 Batch 300 Loss 1.7985 Accuracy 0.2998 Epoch 11 Batch 350 Loss 1.8009 Accuracy 0.2997 Epoch 11 Batch 400 Loss 1.8098 Accuracy 0.2989 Epoch 11 Batch 450 Loss 1.8142 Accuracy 0.2989 Epoch 11 Batch 500 Loss 1.8169 Accuracy 0.2988 Epoch 11 Batch 550 Loss 1.8204 Accuracy 0.2987 Epoch 11 Batch 600 Loss 1.8239 Accuracy 0.2988 Epoch 11 Batch 650 Loss 1.8265 Accuracy 0.2989 Epoch 11 Batch 700 Loss 1.8288 Accuracy 0.2986 Epoch 11 Loss 1.8295 Accuracy 0.2986 Time taken for 1 epoch: 29.374881982803345 secs Epoch 12 Batch 0 Loss 1.5971 Accuracy 0.3350 Epoch 12 Batch 50 Loss 1.6420 Accuracy 0.3110 Epoch 12 Batch 100 Loss 1.6574 Accuracy 0.3081 Epoch 12 Batch 150 Loss 1.6558 Accuracy 0.3081 Epoch 12 Batch 200 Loss 1.6598 Accuracy 0.3072 Epoch 12 Batch 250 Loss 1.6686 Accuracy 0.3080 Epoch 12 Batch 300 Loss 1.6677 Accuracy 0.3088 Epoch 12 Batch 350 Loss 1.6746 Accuracy 0.3083 Epoch 12 Batch 400 Loss 1.6796 Accuracy 0.3079 Epoch 12 Batch 450 Loss 1.6871 Accuracy 0.3072 Epoch 12 Batch 500 Loss 1.6933 Accuracy 0.3067 Epoch 12 Batch 550 Loss 1.6976 Accuracy 0.3065 Epoch 12 Batch 600 Loss 1.7026 Accuracy 0.3063 Epoch 12 Batch 650 Loss 1.7077 Accuracy 0.3066 Epoch 12 Batch 700 Loss 1.7117 Accuracy 0.3065 Epoch 12 Loss 1.7118 Accuracy 0.3065 Time taken for 1 epoch: 29.305912971496582 secs Epoch 13 Batch 0 Loss 1.6015 Accuracy 0.3080 Epoch 13 Batch 50 Loss 1.5318 Accuracy 0.3176 Epoch 13 Batch 100 Loss 1.5372 Accuracy 0.3193 Epoch 13 Batch 150 Loss 1.5449 Accuracy 0.3186 Epoch 13 Batch 200 Loss 1.5585 Accuracy 0.3175 Epoch 13 Batch 250 Loss 1.5678 Accuracy 0.3173 Epoch 13 Batch 300 Loss 1.5719 Accuracy 0.3165 Epoch 13 Batch 350 Loss 1.5787 Accuracy 0.3162 Epoch 13 Batch 400 Loss 1.5831 Accuracy 0.3153 Epoch 13 Batch 450 Loss 1.5898 Accuracy 0.3153 Epoch 13 Batch 500 Loss 1.5935 Accuracy 0.3144 Epoch 13 Batch 550 Loss 1.5990 Accuracy 0.3145 Epoch 13 Batch 600 Loss 1.6024 Accuracy 0.3138 Epoch 13 Batch 650 Loss 1.6086 Accuracy 0.3134 Epoch 13 Batch 700 Loss 1.6109 Accuracy 0.3133 Epoch 13 Loss 1.6110 Accuracy 0.3133 Time taken for 1 epoch: 29.24092197418213 secs Epoch 14 Batch 0 Loss 1.3890 Accuracy 0.2952 Epoch 14 Batch 50 Loss 1.4290 Accuracy 0.3250 Epoch 14 Batch 100 Loss 1.4379 Accuracy 0.3220 Epoch 14 Batch 150 Loss 1.4559 Accuracy 0.3212 Epoch 14 Batch 200 Loss 1.4676 Accuracy 0.3202 Epoch 14 Batch 250 Loss 1.4760 Accuracy 0.3207 Epoch 14 Batch 300 Loss 1.4885 Accuracy 0.3205 Epoch 14 Batch 350 Loss 1.4909 Accuracy 0.3211 Epoch 14 Batch 400 Loss 1.4946 Accuracy 0.3208 Epoch 14 Batch 450 Loss 1.5006 Accuracy 0.3207 Epoch 14 Batch 500 Loss 1.5077 Accuracy 0.3201 Epoch 14 Batch 550 Loss 1.5108 Accuracy 0.3199 Epoch 14 Batch 600 Loss 1.5153 Accuracy 0.3195 Epoch 14 Batch 650 Loss 1.5197 Accuracy 0.3195 Epoch 14 Batch 700 Loss 1.5246 Accuracy 0.3190 Epoch 14 Loss 1.5245 Accuracy 0.3190 Time taken for 1 epoch: 29.347501516342163 secs Epoch 15 Batch 0 Loss 1.4946 Accuracy 0.3085 Epoch 15 Batch 50 Loss 1.3737 Accuracy 0.3301 Epoch 15 Batch 100 Loss 1.3672 Accuracy 0.3284 Epoch 15 Batch 150 Loss 1.3800 Accuracy 0.3283 Epoch 15 Batch 200 Loss 1.3942 Accuracy 0.3271 Epoch 15 Batch 250 Loss 1.3988 Accuracy 0.3272 Epoch 15 Batch 300 Loss 1.4014 Accuracy 0.3269 Epoch 15 Batch 350 Loss 1.4094 Accuracy 0.3262 Epoch 15 Batch 400 Loss 1.4166 Accuracy 0.3257 Epoch 15 Batch 450 Loss 1.4220 Accuracy 0.3255 Epoch 15 Batch 500 Loss 1.4285 Accuracy 0.3256 Epoch 15 Batch 550 Loss 1.4322 Accuracy 0.3253 Epoch 15 Batch 600 Loss 1.4377 Accuracy 0.3249 Epoch 15 Batch 650 Loss 1.4446 Accuracy 0.3244 Epoch 15 Batch 700 Loss 1.4488 Accuracy 0.3238 Saving checkpoint for epoch 15 at ./checkpoints/train/ckpt-3 Epoch 15 Loss 1.4488 Accuracy 0.3239 Time taken for 1 epoch: 29.638850927352905 secs Epoch 16 Batch 0 Loss 1.1991 Accuracy 0.3530 Epoch 16 Batch 50 Loss 1.2971 Accuracy 0.3314 Epoch 16 Batch 100 Loss 1.3096 Accuracy 0.3355 Epoch 16 Batch 150 Loss 1.3160 Accuracy 0.3330 Epoch 16 Batch 200 Loss 1.3200 Accuracy 0.3330 Epoch 16 Batch 250 Loss 1.3260 Accuracy 0.3330 Epoch 16 Batch 300 Loss 1.3348 Accuracy 0.3321 Epoch 16 Batch 350 Loss 1.3402 Accuracy 0.3320 Epoch 16 Batch 400 Loss 1.3455 Accuracy 0.3312 Epoch 16 Batch 450 Loss 1.3533 Accuracy 0.3306 Epoch 16 Batch 500 Loss 1.3593 Accuracy 0.3302 Epoch 16 Batch 550 Loss 1.3660 Accuracy 0.3297 Epoch 16 Batch 600 Loss 1.3730 Accuracy 0.3296 Epoch 16 Batch 650 Loss 1.3783 Accuracy 0.3289 Epoch 16 Batch 700 Loss 1.3819 Accuracy 0.3285 Epoch 16 Loss 1.3820 Accuracy 0.3285 Time taken for 1 epoch: 29.525911331176758 secs Epoch 17 Batch 0 Loss 1.3080 Accuracy 0.3113 Epoch 17 Batch 50 Loss 1.2531 Accuracy 0.3417 Epoch 17 Batch 100 Loss 1.2428 Accuracy 0.3396 Epoch 17 Batch 150 Loss 1.2567 Accuracy 0.3377 Epoch 17 Batch 200 Loss 1.2654 Accuracy 0.3366 Epoch 17 Batch 250 Loss 1.2703 Accuracy 0.3362 Epoch 17 Batch 300 Loss 1.2797 Accuracy 0.3349 Epoch 17 Batch 350 Loss 1.2865 Accuracy 0.3339 Epoch 17 Batch 400 Loss 1.2911 Accuracy 0.3340 Epoch 17 Batch 450 Loss 1.2950 Accuracy 0.3343 Epoch 17 Batch 500 Loss 1.3002 Accuracy 0.3339 Epoch 17 Batch 550 Loss 1.3051 Accuracy 0.3337 Epoch 17 Batch 600 Loss 1.3113 Accuracy 0.3334 Epoch 17 Batch 650 Loss 1.3173 Accuracy 0.3331 Epoch 17 Batch 700 Loss 1.3208 Accuracy 0.3332 Epoch 17 Loss 1.3207 Accuracy 0.3332 Time taken for 1 epoch: 29.23569130897522 secs Epoch 18 Batch 0 Loss 1.0522 Accuracy 0.3385 Epoch 18 Batch 50 Loss 1.1916 Accuracy 0.3437 Epoch 18 Batch 100 Loss 1.1853 Accuracy 0.3432 Epoch 18 Batch 150 Loss 1.1994 Accuracy 0.3435 Epoch 18 Batch 200 Loss 1.2120 Accuracy 0.3424 Epoch 18 Batch 250 Loss 1.2183 Accuracy 0.3406 Epoch 18 Batch 300 Loss 1.2244 Accuracy 0.3403 Epoch 18 Batch 350 Loss 1.2316 Accuracy 0.3405 Epoch 18 Batch 400 Loss 1.2376 Accuracy 0.3396 Epoch 18 Batch 450 Loss 1.2428 Accuracy 0.3395 Epoch 18 Batch 500 Loss 1.2479 Accuracy 0.3394 Epoch 18 Batch 550 Loss 1.2537 Accuracy 0.3390 Epoch 18 Batch 600 Loss 1.2605 Accuracy 0.3380 Epoch 18 Batch 650 Loss 1.2669 Accuracy 0.3376 Epoch 18 Batch 700 Loss 1.2721 Accuracy 0.3369 Epoch 18 Loss 1.2723 Accuracy 0.3368 Time taken for 1 epoch: 29.23801350593567 secs Epoch 19 Batch 0 Loss 1.0786 Accuracy 0.3205 Epoch 19 Batch 50 Loss 1.1217 Accuracy 0.3470 Epoch 19 Batch 100 Loss 1.1432 Accuracy 0.3462 Epoch 19 Batch 150 Loss 1.1478 Accuracy 0.3463 Epoch 19 Batch 200 Loss 1.1571 Accuracy 0.3463 Epoch 19 Batch 250 Loss 1.1640 Accuracy 0.3453 Epoch 19 Batch 300 Loss 1.1716 Accuracy 0.3451 Epoch 19 Batch 350 Loss 1.1778 Accuracy 0.3445 Epoch 19 Batch 400 Loss 1.1814 Accuracy 0.3428 Epoch 19 Batch 450 Loss 1.1885 Accuracy 0.3431 Epoch 19 Batch 500 Loss 1.1956 Accuracy 0.3424 Epoch 19 Batch 550 Loss 1.2013 Accuracy 0.3424 Epoch 19 Batch 600 Loss 1.2084 Accuracy 0.3419 Epoch 19 Batch 650 Loss 1.2147 Accuracy 0.3413 Epoch 19 Batch 700 Loss 1.2212 Accuracy 0.3407 Epoch 19 Loss 1.2213 Accuracy 0.3407 Time taken for 1 epoch: 29.36856746673584 secs Epoch 20 Batch 0 Loss 1.1117 Accuracy 0.3153 Epoch 20 Batch 50 Loss 1.0757 Accuracy 0.3482 Epoch 20 Batch 100 Loss 1.0988 Accuracy 0.3480 Epoch 20 Batch 150 Loss 1.1089 Accuracy 0.3480 Epoch 20 Batch 200 Loss 1.1157 Accuracy 0.3472 Epoch 20 Batch 250 Loss 1.1256 Accuracy 0.3463 Epoch 20 Batch 300 Loss 1.1314 Accuracy 0.3468 Epoch 20 Batch 350 Loss 1.1376 Accuracy 0.3456 Epoch 20 Batch 400 Loss 1.1419 Accuracy 0.3456 Epoch 20 Batch 450 Loss 1.1479 Accuracy 0.3451 Epoch 20 Batch 500 Loss 1.1528 Accuracy 0.3453 Epoch 20 Batch 550 Loss 1.1580 Accuracy 0.3447 Epoch 20 Batch 600 Loss 1.1657 Accuracy 0.3447 Epoch 20 Batch 650 Loss 1.1710 Accuracy 0.3442 Epoch 20 Batch 700 Loss 1.1765 Accuracy 0.3440 Saving checkpoint for epoch 20 at ./checkpoints/train/ckpt-4 Epoch 20 Loss 1.1769 Accuracy 0.3440 Time taken for 1 epoch: 29.240405321121216 secs
평가
평가에는 다음 단계가 사용됩니다.
- 포르투갈어 토크 나이저 (
tokenizer_pt)를 사용하여 입력 문장을 인코딩합니다. 또한 입력이 모델이 학습 된 것과 동일하도록 시작 및 종료 토큰을 추가하십시오. 이것은 인코더 입력입니다. - 디코더 입력은
start token == tokenizer_en.vocab_size입니다. - 패딩 마스크와 미리보기 마스크를 계산합니다.
- 그런 다음
decoder는encoder output과 자체 출력 (자기주의)을 확인하여 예측을 출력합니다. - 마지막 단어를 선택하고 그 argmax를 계산하십시오.
- 예측 된 단어를 디코더에 전달할 때 디코더 입력에 연결합니다.
- 이 접근 방식에서 디코더는 예측 한 이전 단어를 기반으로 다음 단어를 예측합니다.
def evaluate(inp_sentence):
start_token = [tokenizer_pt.vocab_size]
end_token = [tokenizer_pt.vocab_size + 1]
# inp sentence is portuguese, hence adding the start and end token
inp_sentence = start_token + tokenizer_pt.encode(inp_sentence) + end_token
encoder_input = tf.expand_dims(inp_sentence, 0)
# as the target is english, the first word to the transformer should be the
# english start token.
decoder_input = [tokenizer_en.vocab_size]
output = tf.expand_dims(decoder_input, 0)
for i in range(MAX_LENGTH):
enc_padding_mask, combined_mask, dec_padding_mask = create_masks(
encoder_input, output)
# predictions.shape == (batch_size, seq_len, vocab_size)
predictions, attention_weights = transformer(encoder_input,
output,
False,
enc_padding_mask,
combined_mask,
dec_padding_mask)
# select the last word from the seq_len dimension
predictions = predictions[: ,-1:, :] # (batch_size, 1, vocab_size)
predicted_id = tf.cast(tf.argmax(predictions, axis=-1), tf.int32)
# return the result if the predicted_id is equal to the end token
if predicted_id == tokenizer_en.vocab_size+1:
return tf.squeeze(output, axis=0), attention_weights
# concatentate the predicted_id to the output which is given to the decoder
# as its input.
output = tf.concat([output, predicted_id], axis=-1)
return tf.squeeze(output, axis=0), attention_weights
def plot_attention_weights(attention, sentence, result, layer):
fig = plt.figure(figsize=(16, 8))
sentence = tokenizer_pt.encode(sentence)
attention = tf.squeeze(attention[layer], axis=0)
for head in range(attention.shape[0]):
ax = fig.add_subplot(2, 4, head+1)
# plot the attention weights
ax.matshow(attention[head][:-1, :], cmap='viridis')
fontdict = {'fontsize': 10}
ax.set_xticks(range(len(sentence)+2))
ax.set_yticks(range(len(result)))
ax.set_ylim(len(result)-1.5, -0.5)
ax.set_xticklabels(
['<start>']+[tokenizer_pt.decode([i]) for i in sentence]+['<end>'],
fontdict=fontdict, rotation=90)
ax.set_yticklabels([tokenizer_en.decode([i]) for i in result
if i < tokenizer_en.vocab_size],
fontdict=fontdict)
ax.set_xlabel('Head {}'.format(head+1))
plt.tight_layout()
plt.show()
def translate(sentence, plot=''):
result, attention_weights = evaluate(sentence)
predicted_sentence = tokenizer_en.decode([i for i in result
if i < tokenizer_en.vocab_size])
print('Input: {}'.format(sentence))
print('Predicted translation: {}'.format(predicted_sentence))
if plot:
plot_attention_weights(attention_weights, sentence, result, plot)
translate("este é um problema que temos que resolver.")
print ("Real translation: this is a problem we have to solve .")
Input: este é um problema que temos que resolver. Predicted translation: this is a problem we have to contain .... Real translation: this is a problem we have to solve .
translate("os meus vizinhos ouviram sobre esta ideia.")
print ("Real translation: and my neighboring homes heard about this idea .")
Input: os meus vizinhos ouviram sobre esta ideia. Predicted translation: my neighbors heard about this idea . Real translation: and my neighboring homes heard about this idea .
translate("vou então muito rapidamente partilhar convosco algumas histórias de algumas coisas mágicas que aconteceram.")
print ("Real translation: so i 'll just share with you some stories very quickly of some magical things that have happened .")
Input: vou então muito rapidamente partilhar convosco algumas histórias de algumas coisas mágicas que aconteceram. Predicted translation: so i 'm very quickly to share with you some magic stories that had happened . Real translation: so i 'll just share with you some stories very quickly of some magical things that have happened .
디코더의 다른 레이어와주의 블록을 plot 매개 변수에 전달할 수 있습니다.
translate("este é o primeiro livro que eu fiz.", plot='decoder_layer4_block2')
print ("Real translation: this is the first book i've ever done.")
Input: este é o primeiro livro que eu fiz. Predicted translation: this is the first book i did have .
Real translation: this is the first book i've ever done.
요약
이 자습서에서는 위치 인코딩, 다중 머리주의, 마스킹의 중요성 및 변환기를 만드는 방법에 대해 배웠습니다.
다른 데이터 세트를 사용하여 변환기를 훈련 시키십시오. 위의 하이퍼 파라미터를 변경하여 기본 트랜스포머 또는 트랜스포머 XL을 생성 할 수도 있습니다. 여기에 정의 된 레이어를 사용하여 BERT 를 생성하고 최첨단 모델을 학습 할 수도 있습니다. 또한 빔 검색을 구현하여 더 나은 예측을 얻을 수 있습니다.