<h2 style="text-align: justify;">Generative networks</h2>
Recurrent Neural Networks (RNNs) v&agrave; c&aacute;c biến thể được kiểm so&aacute;t của ch&uacute;ng, chẳng hạn như Long Short Term Memory Cells (LSTMs) v&agrave; Gated Recurrent Units (GRUs) đ&atilde; cung cấp một cơ chế để m&ocirc; h&igrave;nh h&oacute;a ng&ocirc;n ngữ, tức l&agrave; ch&uacute;ng c&oacute; thể t&igrave;m hiểu thứ tự từ v&agrave; cung cấp dự đo&aacute;n cho từ tiếp theo trong một chuỗi. Điều n&agrave;y cho ph&eacute;p ch&uacute;ng ta sử dụng RNN cho c&aacute;c t&aacute;c vụ chung, chẳng hạn như tạo văn bản th&ocirc;ng thường, dịch m&aacute;y v&agrave; thậm ch&iacute; cả ch&uacute; th&iacute;ch h&igrave;nh ảnh.
Trong kiến tr&uacute;c RNN m&agrave; ch&uacute;ng ta đ&atilde; thảo luận ở phần trước, mỗi đơn vị RNN tạo ra trạng hidden state dưới dạng đầu ra. Tuy nhi&ecirc;n, ch&uacute;ng ta cũng c&oacute; thể th&ecirc;m một đầu ra kh&aacute;c v&agrave;o mỗi recurrent unit, điều n&agrave;y sẽ cho ph&eacute;p xuất ra một chuỗi (c&oacute; độ d&agrave;i bằng với chuỗi ban đầu). Hơn nữa, ch&uacute;ng ta c&oacute; thể sử dụng c&aacute;c RNN units&nbsp; kh&ocirc;ng chấp nhận đầu v&agrave;o ở mỗi bước v&agrave; chỉ lấy một số vectơ trạng th&aacute;i ban đầu, sau đ&oacute; tạo ra một chuỗi đầu ra.
Điều n&agrave;y cho ph&eacute;p c&aacute;c kiến tr&uacute;c neural kh&aacute;c nhau được hiển thị trong h&igrave;nh dưới đ&acirc;y:
<img style="width: 700px; display: block; margin-left: auto; margin-right: auto;" src="https://tek4.vn/public_files/2c1522d6-7362-4d54-8ccc-24d8819a9190" alt="unreasonable-effectiveness-of-rnn" />
<ul style="text-align: justify;">
<li style="text-align: justify;">One-to-one&nbsp; l&agrave; mạng nơ-ron truyền thống với một đầu v&agrave;o v&agrave; một đầu ra.</li>
<li style="text-align: justify;">One-to-many&nbsp;l&agrave; một kiến tr&uacute;c tổng hợp chấp nhận một gi&aacute; trị đầu v&agrave;o v&agrave; tạo ra một chuỗi c&aacute;c gi&aacute; trị đầu ra. V&iacute; dụ: nếu ch&uacute;ng ta muốn đ&agrave;o tạo mạng phụ đề h&igrave;nh ảnh (image captioning) sẽ tạo ra m&ocirc; tả văn bản của một bức ảnh, ch&uacute;ng ta c&oacute; thể c&oacute; một bức ảnh l&agrave;m đầu v&agrave;o, chuyển n&oacute; qua CNN để c&oacute; được trạng th&aacute;i ẩn v&agrave; sau đ&oacute; c&oacute; chuỗi recurrent tạo ch&uacute; th&iacute;ch từng từ một.</li>
<li style="text-align: justify;">Many-to-one&nbsp;tương ứng với kiến tr&uacute;c RNN m&agrave; ch&uacute;ng ta đ&atilde; m&ocirc; tả trong b&agrave;i trước, chẳng hạn như ph&acirc;n loại văn bản.</li>
<li style="text-align: justify;">Many-to-many hoặc sequence-to-sequence&nbsp;tương ứng với c&aacute;c t&aacute;c vụ như dịch m&aacute;y, trong đ&oacute; RNN đầu ti&ecirc;n ch&uacute;ng ta thu thập tất cả th&ocirc;ng tin từ chuỗi đầu v&agrave;o, v&agrave;o trạng th&aacute;i ẩn v&agrave; một chuỗi RNN kh&aacute;c sẽ unrolls trạng th&aacute;i n&agrave;y v&agrave;o chuỗi đầu ra.&nbsp;</li>
</ul>
Trong phần n&agrave;y, ch&uacute;ng ta sẽ tập trung v&agrave;o c&aacute;c m&ocirc; h&igrave;nh tổng qu&aacute;t đơn giản gi&uacute;p tạo ra văn bản. Để đơn giản hơn, h&atilde;y x&acirc;y dựng mạng ở cấp k&yacute; tự, mạng n&agrave;y tạo ra từng k&yacute; tự văn bản. Trong qu&aacute; tr&igrave;nh đ&agrave;o tạo, ch&uacute;ng ta cần lấy một số corpus văn bản v&agrave; chia n&oacute; th&agrave;nh c&aacute;c chuỗi chữ c&aacute;i.
<pre class="language-python"><code>import torch
import torchtext
import numpy as np
from torchnlp import *
train_dataset,test_dataset,classes,vocab = load_dataset()</code></pre>
<h2 style="text-align: justify;">X&acirc;y dựng vốn từ vựng về k&yacute; tự</h2>
Để x&acirc;y dựng mạng tổng hợp cấp độ k&yacute; tự, ch&uacute;ng ta cần chia văn bản th&agrave;nh c&aacute;c k&yacute; tự ri&ecirc;ng lẻ thay v&igrave; c&aacute;c từ. Điều n&agrave;y c&oacute; thể được thực hiện bằng c&aacute;ch x&aacute;c định một tokenizer kh&aacute;c:&nbsp;
<pre class="language-python"><code>def char_tokenizer(words):
 return list(words) #[word for word in words]

counter = collections.Counter()
for (label, line) in train_dataset:
 counter.update(char_tokenizer(line))
vocab = torchtext.vocab.Vocab(counter)

vocab_size = len(vocab)
print(f"Vocabulary size = {vocab_size}")
print(f"Encoding of 'a' is {vocab.stoi['a']}")
print(f"Character with code 13 is {vocab.itos[13]}")</code></pre>
H&atilde;y xem v&iacute; dụ về c&aacute;ch ch&uacute;ng ta c&oacute; thể m&atilde; h&oacute;a văn bản từ tập dữ liệu của m&igrave;nh:
<pre class="language-python"><code>def enc(x):
 return torch.LongTensor(encode(x,voc=vocab,tokenizer=char_tokenizer))

enc(train_dataset[0][1])</code></pre>
<h2 style="text-align: justify;">Đ&agrave;o tạo một RNN tổng hợp</h2>
C&aacute;ch ch&uacute;ng ta sẽ huấn luyện RNN để tạo văn bản như sau. Tr&ecirc;n mỗi bước, ch&uacute;ng ta sẽ lấy một chuỗi c&aacute;c k&yacute; tự c&oacute; độ d&agrave;i <code>nchars </code>v&agrave; y&ecirc;u cầu mạng tạo k&yacute; tự đầu ra tiếp theo cho mỗi k&yacute; tự đầu v&agrave;o:
<img style="width: 700px; display: block; margin-left: auto; margin-right: auto;" src="https://tek4.vn/public_files/3e2bea04-42f7-4461-916f-9c1f68b05519" alt="rnn-generate" />
T&ugrave;y thuộc v&agrave;o kịch bản thực tế, ch&uacute;ng ta cũng c&oacute; thể muốn bao gồm một số k&yacute; tự đặc biệt, chẳng hạn như end-of-sequence&nbsp;<code>&lt;eos&gt;</code>. Trong trường hợp n&agrave;y, ch&uacute;ng ta chỉ muốn đ&agrave;o tạo mạng để tạo ra văn bản v&ocirc; tận, do đ&oacute; ta sẽ cố định k&iacute;ch thước của mỗi chuỗi bằng với <code>nchars</code> tokens. Do đ&oacute;, mỗi v&iacute; dụ đ&agrave;o tạo sẽ bao gồm đầu v&agrave;o nchars v&agrave; đầu ra nchars (l&agrave; chuỗi đầu v&agrave;o được dịch chuyển một k&yacute; hiệu sang tr&aacute;i). Minibatch sẽ bao gồm một số chuỗi như vậy.&nbsp;
C&aacute;ch ch&uacute;ng ta sẽ tạo c&aacute;c minibatch l&agrave; lấy mỗi văn bản tin tức c&oacute; độ d&agrave;i l, v&agrave; tạo tất cả c&aacute;c kết hợp đầu v&agrave;o-đầu ra c&oacute; thể c&oacute; từ n&oacute; (sẽ c&oacute; l-nchars kết hợp như vậy). Ch&uacute;ng sẽ tạo th&agrave;nh một minibatch v&agrave; k&iacute;ch thước của c&aacute;c minibatch sẽ kh&aacute;c nhau ở mỗi bước đ&agrave;o tạo.
<pre class="language-python"><code>nchars = 100

def get_batch(s,nchars=nchars):
 ins = torch.zeros(len(s)-nchars,nchars,dtype=torch.long,device=device)
 outs = torch.zeros(len(s)-nchars,nchars,dtype=torch.long,device=device)
 for i in range(len(s)-nchars):
 ins[i] = enc(s[i:i+nchars])
 outs[i] = enc(s[i+1:i+nchars+1])
 return ins,outs

get_batch(train_dataset[0][1])</code></pre>
B&acirc;y giờ ch&uacute;ng ta h&atilde;y x&aacute;c định generator network. N&oacute; c&oacute; thể dựa tr&ecirc;n bất kỳ recurrent cell n&agrave;o m&agrave; ch&uacute;ng ta đ&atilde; thảo luận trong phần trước (simple, LSTM hoặc GRU). Trong v&iacute; dụ n&agrave;y, ch&uacute;ng ta sẽ sử dụng LSTM. Bởi v&igrave; mạng lấy c&aacute;c k&yacute; tự l&agrave;m đầu v&agrave;o v&agrave; k&iacute;ch thước từ vựng kh&aacute; nhỏ, ch&uacute;ng t&ocirc;i kh&ocirc;ng cần embedding layer, đầu v&agrave;o được one-hot-encoded c&oacute; thể chuyển trực tiếp đến LSTM cell. Tuy nhi&ecirc;n, bởi v&igrave; ch&uacute;ng ta truyền c&aacute;c số k&yacute; tự l&agrave;m đầu v&agrave;o, n&ecirc;n ta cần one-hot-encode ch&uacute;ng trước khi chuyển sang LSTM. Điều n&agrave;y được thực hiện bằng c&aacute;ch gọi h&agrave;m one_hot trong qu&aacute; tr&igrave;nh chuyển tiếp. Bộ m&atilde; h&oacute;a đầu ra sẽ l&agrave; một lớp tuyến t&iacute;nh sẽ chuyển đổi trạng th&aacute;i ẩn th&agrave;nh đầu ra được one-hot-encoded.
<pre class="language-python"><code>class LSTMGenerator(torch.nn.Module):
 def __init__(self, vocab_size, hidden_dim):
 super().__init__()
 self.rnn = torch.nn.LSTM(vocab_size,hidden_dim,batch_first=True)
 self.fc = torch.nn.Linear(hidden_dim, vocab_size)

 def forward(self, x, s=None):
 x = torch.nn.functional.one_hot(x,vocab_size).to(torch.float32)
 x,s = self.rnn(x,s)
 return self.fc(x),s</code></pre>
Trong qu&aacute; tr&igrave;nh đ&agrave;o tạo, ch&uacute;ng ta muốn c&oacute; thể lấy mẫu văn bản đ&atilde; tạo. Để l&agrave;m điều đ&oacute;, ch&uacute;ng ta định nghĩa h&agrave;m<code>generate</code> sẽ tạo ra chuỗi đầu ra c&oacute; chiều d&agrave;i <code>size</code>, bắt đầu từ chuỗi &nbsp;<code>start</code>.&nbsp;
C&aacute;ch n&oacute; hoạt động như sau. Đầu ti&ecirc;n, ch&uacute;ng ta sẽ chuyển to&agrave;n bộ chuỗi <code>start</code> qua mạng v&agrave; lấy trạng th&aacute;i đầu ra <code>s</code>&nbsp;v&agrave; k&yacute; tự dự đo&aacute;n tiếp theo <code>out</code>. V&igrave; <code>out</code> được one-hot encoded, ch&uacute;ng ta dừng argmax để lấy chỉ mục của k&yacute; tự <code>nc</code> trong từ vựng v&agrave; sử dụng <code>itos </code>để t&igrave;m ra k&yacute; tự thực v&agrave; nối n&oacute; v&agrave;o danh s&aacute;ch k&yacute; tự <code>chars</code>. Qu&aacute; tr&igrave;nh tạo một k&yacute; tự n&agrave;y được lặp lại nhiều lần &nbsp;<code>size</code> để tạo ra số k&yacute; tự cần thiết.&nbsp;
<pre class="language-python"><code>def generate(net,size=100,start='today '):
 chars = list(start)
 out, s = net(enc(chars).view(1,-1).to(device))
 for i in range(size):
 nc = torch.argmax(out[0][-1])
 chars.append(vocab.itos[nc])
 out, s = net(nc.view(1,-1),s)
 return ''.join(chars)</code></pre>
B&acirc;y giờ ch&uacute;ng ta h&atilde;y thực hiện đ&agrave;o tạo! V&ograve;ng lặp đ&agrave;o tạo gần giống như trong tất cả c&aacute;c v&iacute; dụ trước đ&acirc;y, nhưng thay v&igrave; độ ch&iacute;nh x&aacute;c, ch&uacute;ng ta in văn bản được tạo mẫu sau mỗi 1000 epochs.
Cần đặc biệt ch&uacute; &yacute; đến c&aacute;ch ch&uacute;ng ta t&iacute;nh to&aacute;n mất m&aacute;t. Ch&uacute;ng ta cần t&iacute;nh to&aacute;n mất m&aacute;t cho đầu ra được one-hot-encoded v&agrave; <code>text_out </code>văn bản mong đợi, l&agrave; danh s&aacute;ch c&aacute;c chỉ số k&yacute; tự. May mắn thay, h&agrave;m <code>cross_entropy</code> mong đợi đầu ra mạng kh&ocirc;ng chuẩn h&oacute;a (unnormalized network) l&agrave; đối số đầu ti&ecirc;n v&agrave; số lớp l&agrave; đối số thứ hai, ch&iacute;nh x&aacute;c l&agrave; những g&igrave; ch&uacute;ng ta c&oacute;. N&oacute; cũng thực hiện t&iacute;nh trung b&igrave;nh tự động tr&ecirc;n minibatch size.
Ch&uacute;ng ta cũng giới hạn việc đ&agrave;o tạo bằng c&aacute;c mẫu <code>sample_to_train</code>, để kh&ocirc;ng phải đợi qu&aacute; l&acirc;u.&nbsp;
<pre class="language-python"><code>net = LSTMGenerator(vocab_size,64).to(device)

samples_to_train = 10000
optimizer = torch.optim.Adam(net.parameters(),0.01)
loss_fn = torch.nn.CrossEntropyLoss()
net.train()
for i,x in enumerate(train_dataset):
 # x[0] is class label, x[1] is text
 if len(x[1])-nchars&lt;10:
 continue
 samples_to_train-=1
 if not samples_to_train: break
 text_in, text_out = get_batch(x[1])
 optimizer.zero_grad()
 out,s = net(text_in)
 loss = torch.nn.functional.cross_entropy(out.view(-1,vocab_size),text_out.flatten()) #cross_entropy(out,labels)
 loss.backward()
 optimizer.step()
 if i%1000==0:
 print(f"Current loss = {loss.item()}")
 print(generate(net))</code></pre>
V&iacute; dụ n&agrave;y đ&atilde; tạo ra một số văn bản kh&aacute; tốt, nhưng n&oacute; c&oacute; thể được cải thiện hơn nữa theo một số c&aacute;ch:
<ul style="text-align: justify;">
<li>Better minibatch generation. C&aacute;ch ch&uacute;ng ta chuẩn bị dữ liệu để đ&agrave;o tạo l&agrave; tạo một minibatch từ một mẫu. Điều n&agrave;y kh&ocirc;ng l&yacute; tưởng, bởi v&igrave; tất cả c&aacute;c minibatch đều c&oacute; k&iacute;ch thước kh&aacute;c nhau v&agrave; một số trong số ch&uacute;ng thậm ch&iacute; kh&ocirc;ng thể được tạo, v&igrave; văn bản nhỏ hơn <code>nchars</code>. Ngo&agrave;i ra, c&aacute;c minibatch nhỏ kh&ocirc;ng tải đủ GPU. Sẽ l&agrave; kh&ocirc;n ngoan hơn nếu bạn lấy một đoạn văn bản lớn từ tất cả c&aacute;c mẫu, sau đ&oacute; tạo tất cả c&aacute;c cặp đầu v&agrave;o-đầu ra, x&aacute;o trộn ch&uacute;ng v&agrave; tạo ra c&aacute;c minibatch c&oacute; k&iacute;ch thước bằng nhau.</li>
<li>Multilayer LSTM. Bạn n&ecirc;n thử 2 hoặc 3 layers LSTM cells. Như ch&uacute;ng ta đ&atilde; đề cập trong phần trước, mỗi layer LSTM tr&iacute;ch xuất một số mẫu nhất định từ văn bản v&agrave; trong trường hợp tr&igrave;nh tạo cấp k&yacute; tự, ch&uacute;ng ta c&oacute; thể mong đợi cấp LSTM thấp hơn chịu tr&aacute;ch nhiệm tr&iacute;ch xuất &acirc;m tiết v&agrave; cấp cao hơn - cho c&aacute;c từ v&agrave; tổ hợp từ. Điều n&agrave;y c&oacute; thể được thực hiện đơn giản bằng c&aacute;ch chuyển tham số number-of-layer cho h&agrave;m tạo LSTM.</li>
<li>Bạn cũng c&oacute; thể muốn thử nghiệm với c&aacute;c đơn vị GRU v&agrave; xem đơn vị n&agrave;o hoạt động tốt hơn v&agrave; với c&aacute;c k&iacute;ch thước layer ẩn kh&aacute;c nhau. Layer &nbsp;ẩn qu&aacute; lớn c&oacute; thể dẫn đến việc overfitting.</li>
</ul>
Trong định nghĩa trước đ&acirc;y của <code>generate</code>, ch&uacute;ng ta lu&ocirc;n lấy k&yacute; tự c&oacute; x&aacute;c suất cao nhất l&agrave;m k&yacute; tự tiếp theo trong văn bản được tạo. Điều n&agrave;y dẫn đến thực tế l&agrave; văn bản thường 'xoay v&ograve;ng' giữa c&aacute;c chuỗi k&yacute; tự giống nhau lặp đi lặp lại, như trong v&iacute; dụ n&agrave;y:
<pre class="language-python"><code>today of the second the company and a second the company ...</code></pre>
Tuy nhi&ecirc;n, nếu ch&uacute;ng ta nh&igrave;n v&agrave;o ph&acirc;n phối x&aacute;c suất cho k&yacute; tự tiếp theo, c&oacute; thể sự kh&aacute;c biệt giữa một v&agrave;i x&aacute;c suất cao nhất l&agrave; kh&ocirc;ng lớn, v&iacute; dụ: một k&yacute; tự c&oacute; thể c&oacute; x&aacute;c suất 0.2, k&yacute; tự kh&aacute;c - 0.19, v.v. V&iacute; dụ: khi t&igrave;m kiếm k&yacute; tự tiếp theo trong chuỗi 'play', k&yacute; tự tiếp theo cũng c&oacute; thể l&agrave; dấu c&aacute;ch hoặc e.
Điều n&agrave;y dẫn ch&uacute;ng ta đến kết luận rằng kh&ocirc;ng phải l&uacute;c n&agrave;o cũng 'c&ocirc;ng bằng' khi chọn k&yacute; tự c&oacute; x&aacute;c suất cao hơn, bởi v&igrave; việc chọn k&yacute; tự cao thứ hai c&oacute; thể vẫn dẫn ch&uacute;ng ta đến văn bản c&oacute; &yacute; nghĩa. Sẽ kh&ocirc;n ngoan hơn nếu lấy mẫu c&aacute;c k&yacute; tự từ ph&acirc;n phối x&aacute;c suất được đưa ra bởi đầu ra của mạng.
Việc lấy mẫu n&agrave;y c&oacute; thể được thực hiện bằng c&aacute;ch sử dụng h&agrave;m <code>multinomial</code> thực hiện c&aacute;i gọi l&agrave; ph&acirc;n phối đa thức. Một h&agrave;m thực hiện tạo văn bản được định nghĩa dưới đ&acirc;y:
<pre class="language-python"><code>def generate_soft(net,size=100,start='today ',temperature=1.0):
 chars = list(start)
 out, s = net(enc(chars).view(1,-1).to(device))
 for i in range(size):
 #nc = torch.argmax(out[0][-1])
 out_dist = out[0][-1].div(temperature).exp()
 nc = torch.multinomial(out_dist,1)[0]
 chars.append(vocab.itos[nc])
 out, s = net(nc.view(1,-1),s)
 return ''.join(chars)
 
for i in [0.3,0.8,1.0,1.3,1.8]:
 print(f"--- Temperature = {i}\n{generate_soft(net,size=300,start='Today ',temperature=i)}\n")</code></pre>
Ch&uacute;ng ta đ&atilde; đề cập đến một tham số nữa được gọi l&agrave; temperature, được sử dụng để chỉ ra mức độ n&ecirc;n b&aacute;m v&agrave;o x&aacute;c suất cao nhất. Nếu temperature l&agrave; 1.0, ch&uacute;ng ta thực hiện lấy mẫu đa thức c&ocirc;ng bằng v&agrave; khi temperature đi đến v&ocirc; cực - tất cả c&aacute;c x&aacute;c suất trở n&ecirc;n bằng nhau v&agrave; ch&uacute;ng ta chọn ngẫu nhi&ecirc;n k&yacute; tự tiếp theo.&nbsp;

Admin

Generate text với recurrent networks

Cùng tác giả

Admin

Có liên quan