STEP 08 / 18

디코더: 원문을 보면서, 미래는 보지 않고

원본: 디코더

그림 오른쪽이 디코더다. 인코더 층과 다른 점은 서브층이 하나 더 있다는 것이다.

masked self-attention: 지금까지 만든 번역 토큰끼리 본다. tgt_mask로 미래를 가린다.
source attention(encoder-decoder attention): query는 디코더에서, key와 value는 인코더 출력 memory에서 가져온다. "다음 단어를 고르려면 원문의 어디를 봐야 하나?"를 계산하는 자리다. 코드에서 self.src_attn(x, m, m, src_mask)다.
FFN

Decoder는 Encoder와 똑같이 N개를 쌓고 마지막에 LayerNorm을 건다. 차이는 memory, src_mask, tgt_mask를 함께 넘긴다는 것뿐이다.

실행 결과에서 볼 것

디코더 층은 서브층이 3개라 인코더보다 파라미터가 많다(약 2,520만 개).
4, 5번째 입력 토큰만 바꾸면 1~3번째 출력은 차이가 정확히 0이다. 미래를 볼 수 없다는 뜻이다.
마스크를 빼면 1번째 출력까지 바뀐다. 마스크가 없으면 모델이 뒤에 올 정답을 엿보고 학습하게 된다.

코드 변화

+33 −0 · 파일 전체 214줄

이전 단계의 transformer.py와 비교했다. 초록 줄이 새로 생긴 줄, 빨간 줄이 사라진 줄이다.

GitHub에서 보기 ↗

실행 결과

실행한 코드 demo.py 보기

1	import copy
2
3	import torch
4
5	from transformer import (
6	Decoder, DecoderLayer, MultiHeadedAttention, PositionwiseFeedForward, subsequent_mask,
7	)
8
9	torch.manual_seed(0)
10
11	d_model, N = 512, 6
12	c = copy.deepcopy
13	attn = MultiHeadedAttention(8, d_model)
14	ff = PositionwiseFeedForward(d_model, 2048, 0.1)
15	decoder = Decoder(DecoderLayer(d_model, c(attn), c(attn), c(ff), 0.1), N).eval()
16
17	print(f"디코더 층 {len(decoder.layers)}개, 층마다 서브층 {len(decoder.layers[0].sublayer)}개 (self-attn, src-attn, FFN)")
18	print(f"디코더 파라미터 수: {sum(p.numel() for p in decoder.parameters()):,} ← 어텐션이 하나 더 있어 인코더보다 크다")
19	print()
20
21	memory = torch.randn(1, 7, d_model) # 인코더 출력 (원문 토큰 7개)
22	src_mask = torch.ones(1, 1, 7, dtype=torch.bool)
23	y = torch.randn(1, 5, d_model) # 지금까지 만든 번역 토큰 5개
24	out = decoder(y, memory, src_mask, subsequent_mask(5))
25	print("디코더 입력", tuple(y.shape), "+ memory", tuple(memory.shape), "→ 출력", tuple(out.shape))
26	print()
27
28	print("뒤쪽 토큰(4, 5번째)만 바꾸면 앞쪽 출력은?")
29	y2 = y.clone()
30	y2[:, 3:] = torch.randn(1, 2, d_model)
31	out2 = decoder(y2, memory, src_mask, subsequent_mask(5))
32	diff = (out - out2).abs().amax(dim=(0, 2))
33	for i, d in enumerate(diff.tolist()):
34	print(f" {i + 1}번째 토큰 출력 차이: {d:.1e}")
35	print(" → 미래를 가리는 마스크 덕분에 앞 3개는 전혀 바뀌지 않는다")
36	print()
37
38	print("마스크 없이 돌리면?")
39	out3 = decoder(y, memory, src_mask, None)
40	out4 = decoder(y2, memory, src_mask, None)
41	print(f" 1번째 토큰 출력 차이: {(out3 - out4)[:, 0].abs().max().item():.1e} ← 미래를 엿봤다")

디코더 층 6개, 층마다 서브층 3개 (self-attn, src-attn, FFN)
디코더 파라미터 수: 25,225,216  ← 어텐션이 하나 더 있어 인코더보다 크다

디코더 입력 (1, 5, 512) + memory (1, 7, 512) → 출력 (1, 5, 512)

뒤쪽 토큰(4, 5번째)만 바꾸면 앞쪽 출력은?
  1번째 토큰 출력 차이: 0.0e+00
  2번째 토큰 출력 차이: 0.0e+00
  3번째 토큰 출력 차이: 0.0e+00
  4번째 토큰 출력 차이: 4.1e+00
  5번째 토큰 출력 차이: 3.3e+00
  → 미래를 가리는 마스크 덕분에 앞 3개는 전혀 바뀌지 않는다

마스크 없이 돌리면?
  1번째 토큰 출력 차이: 5.8e-01  ← 미래를 엿봤다


1	1		import copy
2	2		import math
3	3
4	4		import torch
5	5		import torch.nn as nn
6	6
7	7
8	8		def attention(query, key, value, mask=None, dropout=None):
9	9		"Compute 'Scaled Dot Product Attention'"
10	10		d_k = query.size(-1)
11	11		scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k)
12	12		if mask is not None:
13	13		scores = scores.masked_fill(mask == 0, -1e9)
14	14		p_attn = scores.softmax(dim=-1)
15	15		if dropout is not None:
16	16		p_attn = dropout(p_attn)
17	17		return torch.matmul(p_attn, value), p_attn
18	18
19	19
20	20		def subsequent_mask(size):
21	21		"Mask out subsequent positions."
22	22		attn_shape = (1, size, size)
23	23		subsequent_mask = torch.triu(torch.ones(attn_shape), diagonal=1).type(
24	24		torch.uint8
25	25		)
26	26		return subsequent_mask == 0
27	27
28	28
29	29		def clones(module, N):
30	30		"Produce N identical layers."
31	31		return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])
32	32
33	33
34	34		class MultiHeadedAttention(nn.Module):
35	35		def __init__(self, h, d_model, dropout=0.1):
36	36		"Take in model size and number of heads."
37	37		super(MultiHeadedAttention, self).__init__()
38	38		assert d_model % h == 0
39	39		# We assume d_v always equals d_k
40	40		self.d_k = d_model // h
41	41		self.h = h
42	42		self.linears = clones(nn.Linear(d_model, d_model), 4)
43	43		self.attn = None
44	44		self.dropout = nn.Dropout(p=dropout)
45	45
46	46		def forward(self, query, key, value, mask=None):
47	47		"Implements Figure 2"
48	48		if mask is not None:
49	49		# Same mask applied to all h heads.
50	50		mask = mask.unsqueeze(1)
51	51		nbatches = query.size(0)
52	52
53	53		# 1) Do all the linear projections in batch from d_model => h x d_k
54	54		query, key, value = [
55	55		lin(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)
56	56		for lin, x in zip(self.linears, (query, key, value))
57	57		]
58	58
59	59		# 2) Apply attention on all the projected vectors in batch.
60	60		x, self.attn = attention(
61	61		query, key, value, mask=mask, dropout=self.dropout
62	62		)
63	63
64	64		# 3) "Concat" using a view and apply a final linear.
65	65		x = (
66	66		x.transpose(1, 2)
67	67		.contiguous()
68	68		.view(nbatches, -1, self.h * self.d_k)
69	69		)
70	70		del query
71	71		del key
72	72		del value
73	73		return self.linears[-1](x)
74	74
75	75
76	76		class PositionwiseFeedForward(nn.Module):
77	77		"Implements FFN equation."
78	78
79	79		def __init__(self, d_model, d_ff, dropout=0.1):
80	80		super(PositionwiseFeedForward, self).__init__()
81	81		self.w_1 = nn.Linear(d_model, d_ff)
82	82		self.w_2 = nn.Linear(d_ff, d_model)
83	83		self.dropout = nn.Dropout(dropout)
84	84
85	85		def forward(self, x):
86	86		return self.w_2(self.dropout(self.w_1(x).relu()))
87	87
88	88
89	89		class Embeddings(nn.Module):
90	90		def __init__(self, d_model, vocab):
91	91		super(Embeddings, self).__init__()
92	92		self.lut = nn.Embedding(vocab, d_model)
93	93		self.d_model = d_model
94	94
95	95		def forward(self, x):
96	96		return self.lut(x) * math.sqrt(self.d_model)
97	97
98	98
99	99		class PositionalEncoding(nn.Module):
100	100		"Implement the PE function."
101	101
102	102		def __init__(self, d_model, dropout, max_len=5000):
103	103		super(PositionalEncoding, self).__init__()
104	104		self.dropout = nn.Dropout(p=dropout)
105	105
106	106		# Compute the positional encodings once in log space.
107	107		pe = torch.zeros(max_len, d_model)
108	108		position = torch.arange(0, max_len).unsqueeze(1)
109	109		div_term = torch.exp(
110	110		torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model)
111	111		)
112	112		pe[:, 0::2] = torch.sin(position * div_term)
113	113		pe[:, 1::2] = torch.cos(position * div_term)
114	114		pe = pe.unsqueeze(0)
115	115		self.register_buffer("pe", pe)
116	116
117	117		def forward(self, x):
118	118		x = x + self.pe[:, : x.size(1)].requires_grad_(False)
119	119		return self.dropout(x)
120	120
121	121
122	122		class LayerNorm(nn.Module):
123	123		"Construct a layernorm module (See citation for details)."
124	124
125	125		def __init__(self, features, eps=1e-6):
126	126		super(LayerNorm, self).__init__()
127	127		self.a_2 = nn.Parameter(torch.ones(features))
128	128		self.b_2 = nn.Parameter(torch.zeros(features))
129	129		self.eps = eps
130	130
131	131		def forward(self, x):
132	132		mean = x.mean(-1, keepdim=True)
133	133		std = x.std(-1, keepdim=True)
134	134		return self.a_2 * (x - mean) / (std + self.eps) + self.b_2
135	135
136	136
137	137		class SublayerConnection(nn.Module):
138	138		"""
139	139		A residual connection followed by a layer norm.
140	140		Note for code simplicity the norm is first as opposed to last.
141	141		"""
142	142
143	143		def __init__(self, size, dropout):
144	144		super(SublayerConnection, self).__init__()
145	145		self.norm = LayerNorm(size)
146	146		self.dropout = nn.Dropout(dropout)
147	147
148	148		def forward(self, x, sublayer):
149	149		"Apply residual connection to any sublayer with the same size."
150	150		return x + self.dropout(sublayer(self.norm(x)))
151	151
152	152
153	153		class EncoderLayer(nn.Module):
154	154		"Encoder is made up of self-attn and feed forward (defined below)"
155	155
156	156		def __init__(self, size, self_attn, feed_forward, dropout):
157	157		super(EncoderLayer, self).__init__()
158	158		self.self_attn = self_attn
159	159		self.feed_forward = feed_forward
160	160		self.sublayer = clones(SublayerConnection(size, dropout), 2)
161	161		self.size = size
162	162
163	163		def forward(self, x, mask):
164	164		"Follow Figure 1 (left) for connections."
165	165		x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))
166	166		return self.sublayer[1](x, self.feed_forward)
167	167
168	168
169	169		class Encoder(nn.Module):
170	170		"Core encoder is a stack of N layers"
171	171
172	172		def __init__(self, layer, N):
173	173		super(Encoder, self).__init__()
174	174		self.layers = clones(layer, N)
175	175		self.norm = LayerNorm(layer.size)
176	176
177	177		def forward(self, x, mask):
178	178		"Pass the input (and mask) through each layer in turn."
179	179		for layer in self.layers:
180	180		x = layer(x, mask)
181	181		return self.norm(x)
	182	+
	183	+
	184	+	class DecoderLayer(nn.Module):
	185	+	"Decoder is made of self-attn, src-attn, and feed forward (defined below)"
	186	+
	187	+	def __init__(self, size, self_attn, src_attn, feed_forward, dropout):
	188	+	super(DecoderLayer, self).__init__()
	189	+	self.size = size
	190	+	self.self_attn = self_attn
	191	+	self.src_attn = src_attn
	192	+	self.feed_forward = feed_forward
	193	+	self.sublayer = clones(SublayerConnection(size, dropout), 3)
	194	+
	195	+	def forward(self, x, memory, src_mask, tgt_mask):
	196	+	"Follow Figure 1 (right) for connections."
	197	+	m = memory
	198	+	x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, tgt_mask))
	199	+	x = self.sublayer[1](x, lambda x: self.src_attn(x, m, m, src_mask))
	200	+	return self.sublayer[2](x, self.feed_forward)
	201	+
	202	+
	203	+	class Decoder(nn.Module):
	204	+	"Generic N layer decoder with masking."
	205	+
	206	+	def __init__(self, layer, N):
	207	+	super(Decoder, self).__init__()
	208	+	self.layers = clones(layer, N)
	209	+	self.norm = LayerNorm(layer.size)
	210	+
	211	+	def forward(self, x, memory, src_mask, tgt_mask):
	212	+	for layer in self.layers:
	213	+	x = layer(x, memory, src_mask, tgt_mask)
	214	+	return self.norm(x)