Tóm tắt chương: 177 Hình dung những gì convnets học

Machine Translated by Google
Hình dung những gì convnets học 177
Tóm tắt chương Convnets
là công cụ tốt nhất để tấn công các vấn đề phân loại trực quan. Convnets hoạt
động bằng cách học một hệ thống phân cấp các mẫu và khái niệm mô-đun
để đại diện cho thế giới thị giác.
Các biểu diễn mà chúng học được rất dễ kiểm tra—convnets đối lập với hộp đen!
Bây giờ bạn có khả năng huấn luyện convnet của riêng mình từ đầu để giải quyết một
vấn đề phân loại hình ảnh.
Bạn hiểu cách sử dụng tính năng tăng cường dữ liệu trực quan để chống lại việc trang
bị quá mức. Bạn biết cách sử dụng convnet được đào tạo trước để trích xuất đặc trưng và
tinh chỉnh.
Bạn có thể tạo trực quan hóa các bộ lọc đã học được bởi mạng kết nối của mình, cũng
như bản đồ nhiệt của hoạt động trong lớp.
Được cấp phép cho <null>

Học sâu cho văn

bản và trình tự
Chương này bao gồm
Tiền xử lý dữ liệu văn bản thành các biểu

diễn hữu ích Làm việc với các mạng
thần kinh hồi quy Sử dụng các convnets 1D để
xử lý chuỗi
Chương này khám phá các mô hình học sâu có thể xử lý văn bản (được hiểu là chuỗi từ
hoặc chuỗi ký tự), chuỗi thời gian và dữ liệu chuỗi nói chung. Hai thuật toán học sâu
cơ bản để xử lý chuỗi là mạng thần kinh tái phát và mạng 1D , phiên bản một chiều của
mạng 2D mà chúng ta đã trình bày trong các chương trước. Chúng ta sẽ thảo luận về cả
hai cách tiếp cận này trong chương này.
Các ứng dụng của các thuật toán này bao gồm: Phân loại
tài liệu và phân loại chuỗi thời gian, chẳng hạn như xác định
chủ đề của một bài báo hoặc tác giả của một cuốn sách
So sánh chuỗi thời gian, chẳng hạn như ước tính mức độ liên quan chặt chẽ của hai tài liệu
ments hoặc hai mã cổ phiếu là
178

179
Học theo trình tự, chẳng hạn như giải mã một câu tiếng Anh thành
người Pháp
Phân tích tình cảm, chẳng hạn như phân loại tình cảm của các tweet hoặc đánh giá phim là tích cực
hay tiêu cực
Dự báo chuỗi thời gian, chẳng hạn như dự đoán thời tiết trong tương lai tại một địa điểm nhất định
tion, đưa ra dữ liệu thời tiết gần đây
Các ví dụ của chương này tập trung vào hai nhiệm vụ hẹp: phân tích cảm tính trên bộ dữ liệu IMDB , một nhiệm vụ mà
chúng ta đã tiếp cận trước đó trong cuốn sách và dự báo nhiệt độ. Tuy nhiên, các kỹ thuật được trình bày cho hai tác vụ
này có liên quan đến tất cả các ứng dụng vừa được liệt kê và nhiều ứng dụng khác.

180 CHƯƠNG 6 Học sâu cho văn bản và trình tự
6.1 Làm việc với dữ liệu văn bản Văn bản
là một trong những dạng phổ biến nhất của dữ liệu chuỗi. Nó có thể được hiểu là một chuỗi ký tự
hoặc một chuỗi từ, nhưng phổ biến nhất là hoạt động ở cấp độ từ. Các mô hình xử lý trình tự học sâu
được giới thiệu trong các phần sau có thể sử dụng văn bản để tạo ra một dạng cơ bản của ngôn ngữ tự
nhiên, đủ cho các ứng dụng bao gồm phân loại tài liệu, phân tích cảm tính, xác định tác giả và thậm
chí trả lời câu hỏi (QA) ( trong một bối cảnh hạn chế). Tất nhiên, hãy ghi nhớ trong suốt chương
này rằng không có mô hình học sâu nào trong số này thực sự hiểu văn bản theo nghĩa của con người;
đúng hơn, những mô hình này có thể ánh xạ cấu trúc thống kê của ngôn ngữ viết, đủ để giải quyết
nhiều tác vụ văn bản đơn giản. Học sâu để xử lý ngôn ngữ tự nhiên là nhận dạng mẫu được áp dụng cho
các từ, câu và đoạn văn, giống như cách thị giác máy tính là nhận dạng mẫu được áp dụng cho pixel.
Giống như tất cả các mạng thần kinh khác, các mô hình học sâu không lấy văn bản thô đầu vào làm
đầu vào: chúng chỉ hoạt động với các tenxơ số. Vector hóa văn bản là quá trình chuyển đổi văn bản
thành các tenxơ số. Điều này có thể được thực hiện theo nhiều cách:
Phân đoạn văn bản thành các từ và biến đổi từng từ thành một vectơ. Phân
đoạn văn bản thành các ký tự và biến đổi từng ký tự thành một vectơ. Trích xuất n-gam
từ hoặc ký tự và biến đổi mỗi n-gam thành một vectơ.
N-gram là các nhóm chồng chéo của nhiều từ hoặc ký tự liên tiếp.
Nói chung, các đơn vị khác nhau mà bạn có thể chia nhỏ văn bản (từ, ký tự hoặc n-gram) được gọi là
mã thông báo và việc chia văn bản thành các mã thông báo như vậy được gọi là mã thông báo . Tất cả
các quy trình vector hóa văn bản đều bao gồm việc áp dụng một số lược đồ mã hóa và sau đó liên kết
các vectơ số với các mã thông báo được tạo. Các vectơ này, được đóng gói thành các tenxơ trình tự,
được đưa vào các mạng lưới thần kinh sâu. Có nhiều cách để liên kết một vectơ với mã thông báo.
Trong phần này, tôi sẽ trình bày hai vấn đề chính: mã hóa mã thông báo một lần nóng và nhúng mã
thông báo (thường được sử dụng riêng cho các từ và được gọi là nhúng từ). Phần còn lại của phần này
giải thích các kỹ thuật này và chỉ ra cách sử dụng chúng để chuyển từ văn bản thô sang tenxơ Numpy
mà bạn có thể gửi tới mạng Keras.
Văn
bản "Con mèo ngồi trên chiếu."
Các thẻ
"the", "cat", "sat", "on", "the", "mat", "."
Mã hóa vectơ của mã thông báo 0,0

0,0 0,4 0,0 0,0 1,0 0,0 0,5 1,0 0,5 0,2 0,5
0,5 0,0 1,0 0,2 1,0 1,0 1,0 0,0 0,0 con mèo
ngồi trên chiếu .
Hình 6.1 Từ văn bản đến
mã thông báo đến vectơ

Làm việc với dữ liệu văn bản 181
Tìm hiểu về n-gam và từ loại n-gam Từ n-gam

là nhóm N (hoặc ít hơn) từ liên tiếp mà bạn có thể trích xuất từ một câu. Khái
niệm tương tự cũng có thể được áp dụng cho các ký tự thay vì từ.
Đây là một ví dụ đơn giản. Xét câu “Con mèo ngồi trên chiếu.” Nó có thể được phân tách
thành tập hợp 2 gam sau:
{"The", "The cat", "cat", "cat sat", "sat",

"sat on", "on", "on the", "the", "the mat", "mat"}
Nó cũng có thể được phân tách thành tập hợp 3 gam sau:
{"Cái", "Con mèo", "con mèo", "con mèo ngồi", "Con mèo ngồi",
"sat", "sat on", "on", "cat sat on", "on the", "the", "sat on the",
"the mat", "mat", "on the mat"}
Một bộ như vậy được gọi tương ứng là túi 2 gam hoặc túi 3 gam. Thuật ngữ túi ở đây đề cập
đến thực tế là bạn đang xử lý một tập hợp các mã thông báo thay vì một danh sách hoặc
chuỗi: các mã thông báo không có thứ tự cụ thể. Nhóm phương pháp mã thông báo này được gọi
là túi từ.
Vì bag-of-words không phải là một phương thức mã thông báo bảo toàn trật tự (các mã thông
báo được tạo ra được hiểu là một tập hợp, không phải một chuỗi và cấu trúc chung của các
ý nghĩa bị mất), nó có xu hướng được sử dụng trong ngôn ngữ nông cạn -xử lý các mô hình
hơn là trong các mô hình học sâu. Trích xuất n-gram là một dạng kỹ thuật tính năng và học
sâu sẽ loại bỏ cách tiếp cận cứng nhắc, dễ vỡ này, thay thế nó bằng học tính năng cổ điển
phân cấp. Mạng một chiều và mạng nơ-ron hồi quy, được giới thiệu ở phần sau của chương
này, có khả năng học các biểu diễn cho các nhóm từ và ký tự mà không cần thông báo rõ ràng
về sự tồn tại của các nhóm đó, bằng cách xem xét các chuỗi từ hoặc ký tự liên tục. Vì lý
do này, chúng tôi sẽ không đề cập đến n-gram nữa trong cuốn sách này. Nhưng hãy nhớ rằng
chúng là một công cụ kỹ thuật tính năng mạnh mẽ, không thể tránh khỏi khi sử dụng các mô
hình xử lý văn bản nông, nhẹ, chẳng hạn như hồi quy logistic và rừng ngẫu nhiên.
6.1.1 Mã hóa một lần các từ và ký tự
Mã hóa một lần là cách phổ biến nhất, cơ bản nhất để biến mã thông báo thành vectơ.
Bạn đã thấy nó hoạt động trong các ví dụ ban đầu của IMDB và Reuters trong chương 3 (trong
trường hợp đó được thực hiện bằng lời nói). Nó bao gồm việc liên kết một chỉ số nguyên duy
nhất với mỗi từ và sau đó biến chỉ số nguyên i này thành một vectơ nhị phân có kích thước N
(kích thước của từ vựng); vectơ là tất cả các số không ngoại trừ mục thứ i, là 1.
Tất nhiên, mã hóa một lần nóng cũng có thể được thực hiện ở cấp độ ký tự. Để hiểu rõ
ràng về mã hóa one-hot là gì và cách triển khai mã hóa đó, danh sách 6.1 và 6.2 đưa ra hai
ví dụ về đồ chơi: một dành cho các từ, một dành cho các ký tự.

Liệt kê 6.1 Mã hóa one-hot cấp độ từ (ví dụ về đồ chơi)
Xây dựng chỉ mục của tất cả các mã thông báo trong dữ liệu
Mã thông báo các mẫu thông qua phương

Dữ liệu ban đầu: một mục nhập cho mỗi mẫu
pháp phân tách. Trong cuộc sống thực, bạn
(trong ví dụ này, mẫu là một câu nhưng có
cũng sẽ loại bỏ dấu chấm câu và các ký
thể là toàn bộ tài liệu)
tự đặc biệt khỏi các mẫu.
nhập numpy dưới dạng np
sample = ['Con mèo ngồi trên chiếu.', 'Con chó ăn bài tập về nhà của tôi.']
token_index = {} cho mẫu
trong mẫu: cho từ trong mẫu.split():
nếu từ không có trong token_index:
token_index[word] = len(token_index) + 1
max_length = 10
results = np.zeros(shape=(len(samples), max_length,
max(token_index.values()) + 1)) for i, sample in
enumerate(samples):
đối với j, từ trong danh sách(enumerate(sample.split()))[:max_length]:
index = token_index.get(word) results[i, j,
index] = 1.
Đây là nơi bạn lưu
trữ kết quả.
Gán một chỉ mục duy nhất cho mỗi từ

duy nhất. Lưu ý rằng bạn không gán chỉ
Vector hóa các mẫu. Bạn sẽ chỉ xem xét
mục 0 cho bất kỳ thứ gì.
các từ max_length đầu tiên trong
mỗi mẫu.
Liệt kê 6.2 Mã hóa one-hot cấp ký tự (ví dụ về đồ chơi)
nhập chuỗi
mẫu = ['Con mèo ngồi trên chiếu.', 'Con chó đã ăn bài tập về nhà của tôi.'] characters = string.printable
token_index = dict(zip(range(1, len(characters) + 1), characters))
max_length = 50 kết quả
= np.zeros((len(samples), max_length, max(token_index.keys()) + 1)) for i, sample in enumerate(samples):
đối với j, ký tự trong kiểu liệt kê(mẫu): index =
token_index.get(character) results[i, j, index] = 1. Tất cả các ký tự ASCII

có thể in được
Lưu ý rằng Keras có các tiện ích tích hợp sẵn để thực hiện mã hóa một lần nóng văn
bản ở cấp độ từ hoặc cấp độ ký tự, bắt đầu từ dữ liệu văn bản thô. Bạn nên sử dụng
các tiện ích này, vì chúng đảm nhiệm một số tính năng quan trọng, chẳng hạn như loại
bỏ các ký tự đặc biệt khỏi chuỗi và chỉ tính đến N từ phổ biến nhất trong tập dữ liệu
của bạn (một hạn chế chung, để tránh xử lý không gian vectơ đầu vào rất lớn ).

Liệt kê 6.3 Sử dụng Keras để mã hóa one-hot cấp độ từ
Tạo mã thông báo, được định cấu hình

để chỉ tính đến 1.000 từ phổ biến
từ keras.preprocessing.text nhập Tokenizer nhất
tokenizer = Tokenizer(num_words=1000)
tokenizer.fit_on_texts(samples)
Xây Biến các chuỗi thành danh
trình tự = tokenizer.texts_to_sequences(mẫu) sách các chỉ số nguyên

dựng
chỉ mục từ one_hot_results = tokenizer.texts_to_matrix(samples, mode='binary')
word_index = tokenizer.word_index print('Đã tìm thấy
%s mã thông báo duy nhất.' % len(word_index))

Làm cách nào bạn có thể
khôi phục chỉ mục từ đã
Bạn cũng có thể trực tiếp lấy các biểu diễn
được tính
nhị phân một lần nóng. Các chế độ vector hóa
khác với mã hóa one-hot được mã thông báo này
hỗ trợ.
Một biến thể của mã hóa one-hot được gọi là thủ thuật băm one-hot, mà bạn có thể sử dụng
khi số lượng mã thông báo duy nhất trong từ vựng của bạn quá lớn để xử lý một cách rõ ràng.
Thay vì chỉ định rõ ràng một chỉ mục cho mỗi từ và giữ tham chiếu của các chỉ mục này
trong từ điển, bạn có thể băm các từ thành các vectơ có kích thước cố định. Điều này
thường được thực hiện với một hàm băm rất nhẹ. Ưu điểm chính của phương pháp này là nó
không cần duy trì chỉ mục từ rõ ràng, giúp tiết kiệm bộ nhớ và cho phép mã hóa dữ liệu
trực tuyến (bạn có thể tạo vectơ mã thông báo ngay lập tức, trước khi bạn xem tất cả dữ
liệu có sẵn). Một nhược điểm của phương pháp này là nó dễ bị xung đột hàm băm: hai từ khác
nhau có thể có cùng một hàm băm và sau đó, bất kỳ mô hình học máy nào nhìn vào các hàm
băm này sẽ không thể phân biệt được sự khác biệt giữa các từ này. Khả năng va chạm băm
giảm khi
kích thước của không gian băm lớn hơn nhiều so với tổng số mã thông báo duy nhất được băm.
Liệt kê 6.4 Mã hóa one-hot cấp độ từ với thủ thuật băm (ví dụ về đồ chơi)
chiều = 1000 max_length = 10
results = np.zeros((len(samples), max_length, dimensions)) for i, sample in enumerate(samples):
đối với j, từ trong danh sách(enumerate(sample.split()))[:max_length]: index = abs(hash(word))

% dimensionality results[i, j, index] = 1.
Băm từ thành một chỉ số
Lưu trữ các từ dưới dạng vectơ có kích thước 1.000. Nếu bạn có gần nguyên ngẫu nhiên trong
khoảng từ 0 đến 1.000
1.000 từ (hoặc nhiều hơn), bạn sẽ thấy nhiều xung đột hàm băm, điều
này sẽ làm giảm độ chính xác của phương pháp mã hóa này.

6.1.2 Sử dụng nhúng từ
Một cách phổ biến và mạnh mẽ khác để liên kết một vectơ với một từ là sử dụng các vectơ từ dày
đặc, còn được gọi là nhúng từ. Trong khi các vectơ thu được thông qua mã hóa một lần nóng là nhị
phân, thưa thớt (hầu hết được tạo bằng số 0) và có chiều rất cao (cùng chiều với số lượng từ
trong từ vựng), từ nhúng là vectơ dấu phẩy động chiều thấp (nghĩa là , vectơ dày đặc, trái ngược
với vectơ thưa thớt); xem hình 6.2. Không giống như các vectơ từ thu được thông qua mã hóa one-
hot, các nhúng từ được học từ dữ liệu. Thường thấy các phần nhúng từ có 256 chiều, 512 chiều
hoặc 1.024 chiều khi xử lý các từ vựng rất lớn. Mặt khác, các từ mã hóa one-hot thường dẫn đến
các vectơ có 20.000 chiều hoặc lớn hơn (thu thập từ vựng gồm 20.000 mã thông báo, trong trường
hợp này). Vì vậy, nhúng từ đóng gói nhiều thông tin hơn vào ít chiều hơn nhiều.
Hình 6.2 Trong khi các biểu diễn từ thu được từ

mã hóa hoặc băm một lần là thưa thớt, nhiều chiều
Vectơ từ một chiều: Từ nhúng:
- Ngu độn và được mã hóa cứng, thì các nhúng từ dày đặc, tương
- Thưa thớt
- Chiều cao - Chiều thấp hơn đối ít chiều và được học từ dữ liệu.
- Mã hóa cứng - Học từ dữ liệu
Có hai cách để có được từ nhúng:
Học cách nhúng từ cùng với nhiệm vụ chính mà bạn quan tâm (chẳng hạn như phân loại tài
liệu hoặc dự đoán cảm xúc). Trong thiết lập này, bạn bắt đầu với các vectơ từ đã chạy và
sau đó tìm hiểu các vectơ từ giống như cách bạn tìm hiểu các trọng số của mạng thần kinh.
Tải vào mô hình của bạn các từ nhúng đã được tính toán trước bằng cách sử dụng một nhiệm
vụ học máy khác với nhiệm vụ bạn đang cố gắng giải quyết. Chúng được gọi là nhúng từ được
đào tạo trước.
Hãy nhìn vào cả hai.

HỌC WORD EMBEDDINGS VỚI EMBEDDING LAYER
Cách đơn giản nhất để liên kết một vectơ dày đặc với một từ là chọn ngẫu nhiên vectơ đó. Vấn
đề với cách tiếp cận này là không gian nhúng kết quả không có cấu trúc: ví dụ: các từ chính
xác và chính xác có thể kết thúc bằng các cách nhúng hoàn toàn khác nhau, mặc dù chúng có
thể hoán đổi cho nhau trong hầu hết các câu. Thật khó để một mạng lưới thần kinh sâu hiểu
được một không gian nhúng ồn ào, không có cấu trúc như vậy.
Để trừu tượng hơn một chút, các mối quan hệ hình học giữa các vectơ từ sẽ phản ánh các
mối quan hệ ngữ nghĩa giữa các từ này. Nhúng từ có nghĩa là ánh xạ ngôn ngữ của con người
vào một không gian hình học. Chẳng hạn, trong một không gian nhúng hợp lý, bạn sẽ mong đợi
các từ đồng nghĩa được nhúng vào các vectơ từ tương tự; và nói chung, bạn sẽ mong đợi khoảng
cách hình học (chẳng hạn như khoảng cách L2) giữa hai vectơ từ bất kỳ liên quan đến khoảng
cách ngữ nghĩa giữa các từ được liên kết (các từ có nghĩa là những thứ khác nhau được nhúng
ở các điểm cách xa nhau, trong khi các từ liên quan gần hơn). Ngoài khoảng cách, bạn có thể
muốn các hướng cụ thể trong không gian nhúng có ý nghĩa. Để làm cho điều này rõ ràng hơn,
chúng ta hãy xem xét một ví dụ cụ thể.
Trong hình 6.3, bốn từ được nhúng trên mặt phẳng 2D : mèo,
chó, sói và hổ. Với các biểu diễn véc tơ mà chúng tôi đã chọn ở
1
chó sói
đây, một số mối quan hệ ngữ nghĩa giữa các từ này có thể được Con hổ
mã hóa dưới dạng các phép biến đổi hình học. Ví dụ, cùng một
vectơ cho phép chúng ta chuyển từ mèo sang hổ và từ chó sang Chú chó
Con mèo
sói: vectơ này có thể được hiểu là vectơ “từ thú cưng đến động
vật hoang dã”. Tương tự, một vectơ khác cho phép chúng ta đi từ 0 x 0
1
chó sang mèo và từ sói sang hổ, có thể hiểu là vectơ “từ răng
nanh đến mèo”. Hình 6.3 Một ví dụ đồ chơi
Trong không gian nhúng từ trong thế giới thực, các ví dụ về không gian nhúng từ
phổ biến về các phép biến đổi hình học có ý nghĩa là vectơ “giới
tính” và vectơ “số nhiều”. Chẳng hạn, bằng cách thêm một vectơ “nữ” vào vectơ “vua”, chúng
ta có được vectơ “nữ hoàng”. Bằng cách thêm một vectơ “số nhiều”, chúng ta có được “các vị vua”.
Các không gian nhúng từ thường có hàng nghìn vectơ có thể hiểu được và có tiềm năng hữu ích
như vậy.
Có không gian nhúng từ lý tưởng nào có thể ánh xạ hoàn hảo ngôn ngữ của con người và có
thể được sử dụng cho bất kỳ tác vụ xử lý ngôn ngữ tự nhiên nào không? Có thể, nhưng chúng
tôi vẫn chưa tính toán bất cứ điều gì thuộc loại này. Ngoài ra, không có thứ gọi là ngôn ngữ
của con người —có nhiều ngôn ngữ khác nhau và chúng không đồng hình, bởi vì ngôn ngữ phản
ánh một nền văn hóa cụ thể và một bối cảnh cụ thể. Nhưng thực tế hơn, điều gì tạo nên một
không gian nhúng từ tốt phụ thuộc rất nhiều vào nhiệm vụ của bạn: không gian nhúng từ hoàn
hảo cho mô hình phân tích tình cảm đánh giá phim bằng tiếng Anh có thể trông khác với không
gian nhúng hoàn hảo cho tài liệu pháp lý bằng tiếng Anh -mô hình phân loại, bởi vì tầm quan
trọng của các mối quan hệ ngữ nghĩa nhất định thay đổi theo từng nhiệm vụ.

Do đó, thật hợp lý khi tìm hiểu một không gian nhúng mới với mọi tác vụ mới. May mắn thay,
backpropagation làm cho điều này trở nên dễ dàng và Keras làm cho nó thậm chí còn dễ dàng hơn.
Đó là về việc tìm hiểu các trọng số của một lớp: lớp Nhúng .
Liệt kê 6.5 Khởi tạo một lớp Nhúng
từ keras.layers nhập Nhúng Lớp Nhúng nhận ít nhất hai đối số:
số lượng mã thông báo có thể có (ở
embedding_layer = Embedding(1000, 64)
đây, 1.000: 1 + chỉ mục từ tối đa) và
kích thước của các nhúng (ở đây, 64).
Lớp Nhúng được hiểu tốt nhất là một từ điển ánh xạ các chỉ số số nguyên (viết tắt của các từ cụ
thể) thành các vectơ dày đặc. Nó lấy các số nguyên làm đầu vào, nó tra cứu các số nguyên này
trong từ điển nội bộ và trả về các vectơ liên quan. Đó thực sự là một cách tra cứu từ điển (xem
hình 6.4).
chỉ mục từ lớp nhúng Vectơ từ tương ứng
Hình 6.4 Lớp Nhúng
Lớp Nhúng lấy đầu vào là một tenxơ 2D của các số nguyên, có hình dạng (mẫu, chiều dài chuỗi),
trong đó mỗi mục nhập là một chuỗi các số nguyên. Nó có thể nhúng các chuỗi có độ dài thay đổi:
ví dụ: bạn có thể đưa vào lớp Nhúng trong các lô ví dụ trước có hình dạng (32, 10) (lô 32 chuỗi
có độ dài 10) hoặc (64, 15) (lô 64 chuỗi có chiều dài 15). Tuy nhiên, tất cả các chuỗi trong
một lô phải có cùng độ dài (vì bạn cần đóng gói chúng vào một tenxơ duy nhất), do đó, các chuỗi
ngắn hơn các chuỗi khác nên được đệm bằng số 0 và các chuỗi dài hơn nên được cắt bớt.
Lớp này trả về một thang đo dấu phẩy động 3D có hình dạng (mẫu, chiều dài trình tự,
chiều_nhúng). Một tenxơ 3D như vậy sau đó có thể được xử lý bởi lớp RNN hoặc lớp tích chập 1D
(cả hai sẽ được giới thiệu trong các phần sau).
Khi bạn khởi tạo một lớp Nhúng , các trọng số của nó (từ điển bên trong của các vectơ mã
thông báo) ban đầu là ngẫu nhiên, giống như với bất kỳ lớp nào khác. Trong quá trình đào tạo,
các vectơ từ này dần dần được điều chỉnh thông qua lan truyền ngược, cấu trúc không gian thành
thứ mà mô hình xuôi dòng có thể khai thác. Sau khi được đào tạo đầy đủ, không gian nhúng sẽ hiển
thị rất nhiều cấu trúc—một loại cấu trúc chuyên biệt cho vấn đề cụ thể mà bạn đang đào tạo mô
hình của mình.
Hãy áp dụng ý tưởng này cho nhiệm vụ dự đoán cảm xúc đánh giá phim IMDB mà bạn đã quen
thuộc. Đầu tiên, bạn sẽ nhanh chóng chuẩn bị dữ liệu. Bạn sẽ giới hạn các bài đánh giá phim
trong 10.000 từ phổ biến nhất (như bạn đã làm trong lần đầu tiên làm việc với tập dữ liệu này)
và cắt bỏ các bài đánh giá chỉ sau 20 từ. Mạng sẽ học cách nhúng 8 chiều cho mỗi từ trong số
10.000 từ, biến số nguyên đầu vào

các chuỗi (tenxơ số nguyên 2D) thành các chuỗi nhúng (tenxơ float 3D ), làm phẳng tenxơ
thành 2D và huấn luyện một lớp Dense duy nhất trên cùng để phân loại.
Liệt kê 6.6 Đang tải dữ liệu IMDB để sử dụng với lớp Nhúng
từ máy ảnh.datasets nhập imdb từ máy ảnh nhập

Cắt bỏ văn bản sau này
tiền xử lý Số từ được coi là tính
năng số lượng từ (trong số các
max_features = 10000 maxlen = từ phổ biến nhất trong
20 max_features)
(x_train, y_train), (x_test, y_test) = imdb.load_data( num_words=max_features)
Tải dữ liệu dưới dạng danh sách các số nguyên
x_train = tiền xử lý.sequence.pad_sequences(x_train, maxlen=maxlen x_test = tiền xử

lý.sequence.pad_sequences(x_test, maxlen=maxlen)
Biến danh sách các số nguyên

thành một tenxơ số nguyên 2D
có dạng (samples, maxlen)
Liệt kê 6.7 Sử dụng lớp Nhúng và bộ phân loại trên dữ liệu IMDB
Chỉ định độ dài đầu vào tối đa cho lớp

Nhúng để sau này bạn có thể làm phẳng các
đầu vào được nhúng. Sau lớp nhúng, kích hoạt
Làm phẳng tensor 3D của
có hình dạng (samples, maxlen, 8).
các phần nhúng thành một
tensor 2D có dạng (mẫu,
từ keras.models nhập Tuần tự từ keras.layers nhập Làm
maxlen * 8)
phẳng, dày đặc
model = Sequential()
model.add(Embedding(10000, 8, input_length=maxlen))
model.add(Làm phẳng()) thêm

phân loại trên đầu trang
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) model.summary()
history = model.fit(x_train, y_train, epochs=10,

batch_size=32,
validation_split=0.2)
Bạn có được độ chính xác xác thực là ~76%, điều này khá tốt khi bạn chỉ xem 20 từ đầu tiên
trong mỗi bài đánh giá. Nhưng lưu ý rằng việc chỉ làm phẳng các chuỗi được nhúng và đào tạo
một Lớp dày đặc duy nhất ở trên cùng sẽ dẫn đến một mô hình xử lý riêng từng từ trong chuỗi
đầu vào mà không xem xét mối quan hệ giữa các từ và cấu trúc câu (ví dụ: mô hình này có thể
sẽ xử lý cả “ bộ phim này là một quả bom” và “bộ phim này là quả bom” là những đánh giá
tiêu cực). Sẽ tốt hơn nhiều nếu thêm các lớp hồi quy hoặc lớp tích chập 1D lên trên các
trình tự được nhúng để tìm hiểu các tính năng có tính đến toàn bộ từng trình tự.
Đó là những gì chúng ta sẽ tập trung vào trong một vài phần tiếp theo.

SỬ DỤNG WORD NHÚNG ĐƯỢC ĐÀO TẠO TRƯỚC
Đôi khi, bạn có quá ít dữ liệu đào tạo nên bạn không thể chỉ sử dụng dữ liệu của mình để tìm
hiểu cách nhúng từ vựng phù hợp cho từng nhiệm vụ cụ thể. Sau đó bạn làm gì?
Thay vì học cách nhúng từ cùng với vấn đề bạn muốn giải quyết, bạn có thể tải các vectơ
nhúng từ một không gian nhúng được tính toán trước mà bạn biết là có cấu trúc cao và thể hiện
các thuộc tính hữu ích—giúp nắm bắt các khía cạnh chung của cấu trúc ngôn ngữ. Cơ sở lý luận
đằng sau việc sử dụng các lệnh nhúng từ được đào tạo trước trong xử lý ngôn ngữ tự nhiên cũng
giống như việc sử dụng mạng đối lưu được đào tạo trước trong phân loại hình ảnh: bạn không có
đủ dữ liệu để tự mình tìm hiểu các tính năng thực sự mạnh mẽ, nhưng bạn mong đợi các tính năng
mà bạn cần phải khá chung chung—nghĩa là các đặc điểm hình ảnh phổ biến hoặc các đặc điểm ngữ
nghĩa. Trong trường hợp này, sẽ rất hợp lý khi sử dụng lại các tính năng đã học cho một vấn đề
khác.
Việc nhúng từ như vậy thường được tính toán bằng cách sử dụng số liệu thống kê về số lần
xuất hiện từ (quan sát về những từ nào cùng xuất hiện trong câu hoặc tài liệu), sử dụng nhiều
kỹ thuật, một số liên quan đến mạng lưới thần kinh, một số khác thì không. Ý tưởng về một không
gian nhúng dày đặc, ít chiều cho các từ, được tính toán theo cách không giám sát, ban đầu được
khám phá bởi Bengio et al. vào đầu những năm 2000,1 nhưng nó chỉ bắt đầu cất cánh trong các ứng
dụng nghiên cứu và công nghiệp sau khi phát hành một trong những chương trình nhúng từ nổi
tiếng và thành công nhất: thuật toán Word2vec ( https://code.google.com/archive /p/word2vec), do
Tomas Mikolov phát triển tại Google vào năm 2013. Thứ nguyên Word2vec nắm bắt các thuộc tính
ngữ nghĩa cụ thể, chẳng hạn như giới tính.

Có nhiều cơ sở dữ liệu nhúng từ được tính toán trước khác nhau mà bạn có thể tải xuống và
sử dụng trong lớp Nhúng Keras . Word2vec là một trong số đó. Một cách phổ biến khác được gọi là
Vectơ toàn cầu để biểu diễn từ (GloVe, https://nlp.stanford .edu/projects/glove), được phát
triển bởi các nhà nghiên cứu của Stanford vào năm 2014. Kỹ thuật nhúng này dựa trên việc phân
tích hệ số một ma trận thống kê các từ cùng xuất hiện. Các nhà phát triển của nó đã tạo sẵn các
phần nhúng được tính toán trước cho hàng triệu mã thông báo bằng tiếng Anh, thu được từ dữ liệu
Wikipedia và dữ liệu Thu thập thông tin chung.
Hãy xem cách bạn có thể bắt đầu sử dụng nhúng GloVe trong mô hình Keras.
Phương pháp tương tự cũng hợp lệ đối với nhúng Word2vec hoặc bất kỳ cơ sở dữ liệu nhúng từ nào
khác. Bạn cũng sẽ sử dụng ví dụ này để làm mới các kỹ thuật mã hóa văn bản được giới thiệu ở
một vài đoạn trước: bạn sẽ bắt đầu từ văn bản thô và tiến dần lên.
6.1.3 Kết hợp tất cả lại với nhau: từ văn bản thô đến nhúng từ
Bạn sẽ sử dụng một mô hình tương tự như mô hình mà chúng ta vừa xem qua: nhúng các câu theo
trình tự các vectơ, làm phẳng chúng và huấn luyện một lớp Dense ở trên cùng. Nhưng bạn sẽ làm
như vậy bằng cách sử dụng các từ nhúng được đào tạo trước; và thay vì sử dụng dữ liệu IMDB tiền
mã hóa được đóng gói trong Keras, bạn sẽ bắt đầu lại từ đầu bằng cách tải xuống dữ liệu văn bản gốc.
1
Yoshua Bengio và cộng sự, Các mô hình ngôn ngữ xác suất thần kinh (Springer, 2003).

TẢI XUỐNG DỮ LIỆU IMDB DƯỚI VĂN BẢN NGUYÊN
Đầu tiên, hãy truy cập http://mng.bz/0tIo và tải xuống tập dữ liệu IMDB thô . Giải nén nó.
Bây giờ, hãy thu thập các đánh giá đào tạo riêng lẻ thành một danh sách các chuỗi, mỗi chuỗi một
xem xét lại. Bạn cũng sẽ thu thập các nhãn đánh giá (tích cực/tiêu cực) vào danh sách nhãn .
Liệt kê 6.8 Xử lý nhãn của dữ liệu IMDB thô
nhập hệ điều hành
imdb_dir = '/Users/fchollet/Downloads/aclImdb' train_dir =
os.path.join(imdb_dir, 'train')
nhãn = [] văn
bản = []
cho nhãn_type trong ['neg', 'pos']:

dir_name = os.path.join(train_dir, label_type) cho fname trong
os.listdir(dir_name):
if fname[-4:] == '.txt': f =
open(os.path.join(dir_name, fname)) text.append(f.read())

f.close() if label_type == 'neg ':
nhãn.append(0)
khác:
nhãn.append(1)
TOKEN HÓA DỮ LIỆU
Hãy vector hóa văn bản và chuẩn bị phân tách đào tạo và xác thực, sử dụng các khái niệm đã giới
thiệu trước đó trong phần này. Bởi vì nhúng từ được đào tạo trước nhằm mục đích đặc biệt hữu ích
đối với các vấn đề có ít dữ liệu đào tạo (nếu không, các nhúng dành riêng cho nhiệm vụ có khả năng
hoạt động tốt hơn chúng), chúng tôi sẽ thêm bước ngoặt sau: giới hạn dữ liệu đào tạo ở 200 mẫu đầu
tiên. Vì vậy, bạn sẽ học cách phân loại các bài phê bình phim sau khi chỉ xem 200 ví dụ.
Liệt kê 6.9 Mã hóa văn bản của dữ liệu IMDB thô
từ keras.preprocessing.text nhập Mã thông báo từ keras.preprocessing.sequence
nhập pad_sequences nhập numpy dưới dạng np
tối đa = 100 Cắt bỏ đánh giá sau 100 từ
training_samples = 200 Xe lửa trên 200 mẫu

validation_samples = 10000 Xác thực trên 10.000 mẫu
max_words = 10000
Chỉ xem xét 10.000

tokenizer = Tokenizer(num_words=max_words)
từ hàng đầu trong tập dữ liệu
tokenizer.fit_on_texts(text) sequences =
tokenizer.texts_to_sequences(text)

word_index = tokenizer.word_index print('Đã tìm
thấy %s mã thông báo duy nhất.' % len(word_index))
dữ liệu = pad_sequences(dãy, maxlen=maxlen)
nhãn = np.asarray(nhãn) print('Hình dạng
của tenxơ dữ liệu:', data.shape) print('Hình dạng của tenxơ
nhãn:', label.shape)
chỉ số = np.arange(data.shape[0]) np.random.shuffle(chỉ

Chia dữ liệu thành một tập huấn luyện và một
số) dữ liệu = dữ liệu[chỉ số]
tập hợp xác thực, nhưng trước tiên hãy xáo
trộn dữ liệu, vì bạn đang bắt đầu với dữ liệu
nhãn = nhãn [chỉ số] trong đó các mẫu được sắp xếp (tất cả âm trước,
sau đó tất cả dương)
x_train = data[:training_samples] y_train =
label[:training_samples]
x_val = dữ liệu[training_samples: training_samples + validation_samples] y_val = nhãn[training_samples:
training_samples + validation_samples]
TẢI XUỐNG GĂNG TAY NHÚNG WORD
Truy cập https://nlp.stanford.edu/projects/glove, và tải xuống các bản nhúng được tính toán
trước từ Wikipedia tiếng Anh năm 2014. Đó là một tệp nén 822 MB có tên là gloves.6B.zip,
chứa các vectơ nhúng 100 chiều cho 400.000 từ (hoặc mã thông báo không phải từ). Giải nén nó.
XỬ LÝ TRƯỚC BẢNG NHẬP
Hãy phân tích cú pháp tệp đã giải nén (tệp .txt) để tạo chỉ mục ánh xạ các từ (dưới dạng
chuỗi) sang biểu diễn vectơ của chúng (dưới dạng vectơ số).
Liệt kê 6.10 Phân tích cú pháp tệp nhúng từ GloVe
Glove_dir = '/Users/fchollet/Downloads/glove.6B'
embeddings_index = {} f =
open(os.path.join(glove_dir, 'glove.6B.100d.txt')) cho dòng trong f:
giá trị = line.split() word =

value[0] coefs =
np.asarray(values[1:], dtype='float32') embeddings_index[word] = coefs

f.close()
print('Đã tìm thấy %s vectơ từ.' % len(embeddings_index))
Tiếp theo, bạn sẽ xây dựng một ma trận nhúng mà bạn có thể tải vào một lớp Nhúng . Nó phải
là một ma trận có hình dạng (max_words, embedding_dim), trong đó mỗi mục nhập i chứa vectơ
chiều embedding_dim cho từ của chỉ mục i trong chỉ mục từ tham chiếu (được tạo trong quá
trình mã hóa). Lưu ý rằng chỉ mục 0 không được phép đại diện cho bất kỳ từ hoặc mã thông báo
nào—đó là một trình giữ chỗ.

Liệt kê 6.11 Chuẩn bị ma trận nhúng từ GloVe
embedding_dim = 100
embedding_matrix = np.zeros((max_words, embedding_dim)) cho từ, i trong

word_index.items(): nếu i < max_words: embedding_vector = embeddings_index.get(word)
nếu embedding_vector không có Không có: embedding_matrix[i] = embedding_vector
Các từ không được tìm thấy
trong chỉ mục nhúng sẽ là tất

cả các số không.
XÁC ĐỊNH MỘT MÔ HÌNH
Bạn sẽ sử dụng kiến trúc mô hình giống như trước đây.
Liệt kê 6.12 Định nghĩa mô hình
từ keras.models nhập Tuần tự từ keras.layers nhập

Nhúng, Làm phẳng, Mật độ
model.add(Embedding(max_words, embedding_dim, input_length=maxlen)) model.add(Flatten()) model.add(Dense(32,
activation='relu')) model.add(Dense(1 , activation='sigmoid')) model.summary()
TẢI GĂNG TAY NHÚNG TRONG MÔ HÌNH
Lớp Nhúng có một ma trận trọng số duy nhất: một ma trận nổi 2D trong đó mỗi mục nhập i là vectơ từ có nghĩa là
được liên kết với chỉ mục i. Đủ đơn giản. Tải ma trận GloVe mà bạn đã chuẩn bị vào lớp Nhúng , lớp đầu tiên
trong mô hình.
Liệt kê 6.13 Đang tải các từ nhúng đã được huấn luyện trước vào lớp Nhúng
model.layers[0].set_weights([embedding_matrix]) model.layers[0].trainable
= False
Ngoài ra, bạn sẽ đóng băng lớp Nhúng (đặt thuộc tính có thể đào tạo thành Sai), theo cùng một lý do mà bạn đã
quen thuộc trong ngữ cảnh của các tính năng convnet được đào tạo trước: khi các phần của mô hình được đào tạo
trước (như lớp Nhúng của bạn ) và các phần được khởi tạo ngẫu nhiên (như trình phân loại của bạn), các phần được
đào tạo trước không nên được cập nhật trong quá trình đào tạo, để tránh quên những gì chúng đã biết. Các bản cập
nhật cấp độ lớn được kích hoạt bởi các lớp được khởi tạo ngẫu nhiên sẽ gây gián đoạn cho các tính năng đã được
học.

ĐÀO TẠO VÀ ĐÁNH GIÁ MÔ HÌNH
Biên dịch và huấn luyện mô hình.
Liệt kê 6.14 Đào tạo và đánh giá
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
dimensions=['acc']) history =
model.fit(x_train, y_train, epochs=10, batch_size=32,
validation_data=(x_val, y_val))
model.save_weights('pre_training_glove_model.h5')
Bây giờ, vẽ biểu đồ hiệu suất của mô hình theo thời gian (xem hình 6.5 và 6.6).
Liệt kê 6.15 Vẽ đồ thị kết quả
nhập matplotlib.pyplot dưới dạng plt
acc = history.history['acc'] val_acc =

history.history['val_acc'] loss = history.history['loss']
val_loss = history.history['val_loss']
kỷ nguyên = phạm vi (1, len (acc) + 1)
plt.plot(epochs, acc, 'bo', label='Training acc') plt.plot(epochs, val_acc,

'b', label='Acvalidation acc') plt.title('Độ chính xác của quá trình đào tạo và
xác thực') plt .huyền thoại()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Mất quá trình đào tạo') plt.plot(epochs,

val_loss, 'b', label='Mất quá trình xác thực') plt.title('Mất quá trình đào tạo và
plt.show()
Hình 6.5 Mất kiểm tra và đào tạo khi sử dụng

nhúng từ được đào tạo trước

Hình 6.6 Độ chính xác của quá
trình huấn luyện và xác thực khi sử
dụng nhúng từ được huấn luyện trước
Mô hình nhanh chóng bắt đầu quá khớp, điều này không có gì đáng ngạc nhiên với số lượng
mẫu đào tạo nhỏ. Độ chính xác xác thực có phương sai cao vì lý do tương tự, nhưng có vẻ
như nó đạt đến mức cao nhất là 50.
Lưu ý rằng số dặm của bạn có thể thay đổi: vì bạn có quá ít mẫu đào tạo nên hiệu suất
của mance phụ thuộc rất nhiều vào chính xác 200 mẫu bạn chọn—và bạn chọn chúng một cách
ngẫu nhiên. Nếu điều này hoạt động kém với bạn, hãy thử chọn một bộ 200 mẫu ran dom khác,
vì mục đích của bài tập (trong cuộc sống thực, bạn không được chọn dữ liệu huấn luyện của
mình).
Bạn cũng có thể huấn luyện mô hình tương tự mà không cần tải các lệnh nhúng từ đã
được huấn luyện trước và không đóng băng lớp nhúng. Trong trường hợp đó, bạn sẽ tìm hiểu
về cách nhúng mã thông báo đầu vào theo nhiệm vụ cụ thể, cách này thường hiệu quả hơn so
với cách nhúng từ được đào tạo trước khi có nhiều dữ liệu. Nhưng trong trường hợp này,
bạn chỉ có 200 mẫu đào tạo. Hãy thử xem (xem hình 6.7 và 6.8).
Liệt kê 6.16 Huấn luyện cùng một mô hình mà không cần nhúng từ đã được huấn luyện trước
từ keras.models nhập Tuần tự từ keras.layers nhập

Nhúng, Làm phẳng, Mật độ
model.add(Embedding(max_words, embedding_dim, input_length=maxlen)) model.add(Flatten()) model.add(Dense(32,
activation='relu')) model.add(Dense(1 , activation='sigmoid')) model.summary()


Hình 6.7 Mất kiểm tra và

đào tạo mà không sử dụng nhúng
từ được đào tạo trước
Hình 6.8 Độ chính xác của đào tạo và

xác thực mà không cần sử dụng nhúng
từ được đào tạo trước
Độ chính xác xác thực bị đình trệ trong những năm 50 thấp. Vì vậy, trong trường hợp này, các nhúng từ
được đào tạo trước hoạt động tốt hơn các nhúng được học chung. Nếu bạn tăng số lượng mẫu huấn luyện,
điều này sẽ nhanh chóng không còn xảy ra nữa—hãy thử nó như một bài tập.
Cuối cùng, hãy đánh giá mô hình trên dữ liệu thử nghiệm. Trước tiên, bạn cần mã hóa dữ liệu thử
nghiệm.
Liệt kê 6.17 Token hóa dữ liệu của tập kiểm tra
test_dir = os.path.join(imdb_dir, 'test')
nhãn = [] văn
bản = []
cho nhãn_type trong ['neg', 'pos']:

dir_name = os.path.join(test_dir, label_type) for fname in
sorted(os.listdir(dir_name)): if fname[-4:] == '.txt': f =
open(os.path.join(dir_name , fname)) text.append(f.read())

f.close()
nếu nhãn_type == 'neg':

nhãn.append(0)
khác:
nhãn.append(1)
trình tự = tokenizer.texts_to_sequences(văn bản) x_test =

pad_sequences(trình tự, maxlen=maxlen) y_test = np.asarray(nhãn)
Tiếp theo, tải và đánh giá mô hình đầu tiên.
Liệt kê 6.18 Đánh giá mô hình trên tập kiểm tra
model.load_weights('pre_training_glove_model.h5') model.evaluate(x_test,
y_test)
Bạn nhận được độ chính xác kiểm tra kinh khủng là 56%. Làm việc chỉ với một số ít các mẫu đào
tạo là khó khăn!
6.1.4 Kết thúc

Bây giờ bạn có thể làm như sau:
Biến văn bản thô thành thứ mà mạng thần kinh có thể xử lý Sử
dụng lớp Nhúng trong mô hình Máy ảnh để tìm hiểu cách nhúng mã thông báo theo nhiệm vụ cụ thể
tiếng kêu
Sử dụng các nhúng từ được đào tạo trước để tăng thêm
vấn đề xử lý ngôn ngữ

6.2 Tìm hiểu về mạng nơ-ron hồi quy Một đặc điểm chính của tất cả
các mạng nơ-ron mà bạn đã thấy cho đến nay, chẳng hạn như mạng kết nối dày đặc và mạng kết nối,
là chúng không có bộ nhớ. Mỗi đầu vào hiển thị cho họ được xử lý độc lập, không có trạng thái
nào được lưu giữ giữa các đầu vào. Với các công trình mạng như vậy, để xử lý một chuỗi hoặc một
chuỗi các điểm dữ liệu theo thời gian, bạn phải hiển thị toàn bộ chuỗi đó cho mạng cùng một lúc:
biến nó thành một điểm dữ liệu duy nhất. Chẳng hạn, đây là những gì bạn đã làm trong ví dụ IMDB:
toàn bộ bài đánh giá phim được chuyển đổi thành một vectơ lớn duy nhất và được xử lý trong một
lần. Các mạng như vậy được gọi là mạng feedforward.
Ngược lại, khi bạn đang đọc câu hiện tại, bạn đang xử lý nó từng từ một—hay đúng hơn là nhìn
lướt qua mắt—trong khi lưu giữ những ký ức về những gì đã xảy ra trước đó; điều này cung cấp cho
bạn một đại diện linh hoạt về ý nghĩa được chuyển tải bởi câu này.
Trí thông minh sinh học xử lý thông tin tăng dần trong khi vẫn duy trì một mô hình nội bộ về
những gì nó đang xử lý, được xây dựng từ thông tin trong quá khứ và được cập nhật liên tục khi
có thông tin mới.
Mạng thần kinh hồi quy (RNN) áp dụng nguyên tắc tương tự, mặc dù ở phiên bản cực kỳ đơn giản:
nó xử lý các chuỗi bằng cách lặp qua các phần tử chuỗi và duy trì trạng thái chứa thông tin liên
quan đến những gì nó đã thấy cho đến nay. Trên thực tế, RNN là một loại mạng thần kinh có vòng
đầu ra
lặp bên trong (xem hình 6.9).
Trạng thái của RNN được đặt lại giữa quá trình xử lý hai chuỗi RNN
kết nối định
độc lập, khác nhau (chẳng hạn như hai đánh giá IMDB khác nhau ), kỳ
vì vậy bạn vẫn coi một chuỗi là một điểm dữ liệu duy nhất: một
đầu vào duy nhất cho mạng. Điều thay đổi là điểm dữ liệu này Đầu vào
không còn được xử lý trong một bước nữa; thay vào đó, mạng nội Hình 6.9 Mạng hồi quy: mạng có
bộ lặp qua các phần tử trình tự. vòng lặp
Để làm rõ các khái niệm về vòng lặp và trạng thái này, hãy triển khai chuyển tiếp chuyển tiếp
của RNN đồ chơi trong Numpy. RNN này lấy đầu vào là một chuỗi vectơ mà bạn sẽ mã hóa dưới dạng
tenxơ 2D có kích thước (dấu thời gian, tính năng_đầu vào). Nó lặp qua các dấu thời gian và tại
mỗi dấu thời gian, nó xem xét trạng thái hiện tại của nó tại t và đầu vào tại t (hình dạng (tính
năng_ đầu vào,) và kết hợp chúng để thu được đầu ra tại t. Sau đó, bạn sẽ đặt trạng thái cho
bước tiếp theo là đầu ra trước đó. Đối với dấu thời gian đầu tiên, đầu ra trước đó không được
xác định; do đó, không có trạng thái hiện tại. Vì vậy, bạn sẽ khởi tạo trạng thái dưới dạng một
vectơ hoàn toàn bằng 0 được gọi là trạng thái ban đầu của mạng.
Trong mã giả, đây là RNN.
Liệt kê 6.19 Mã giả RNN
bang_t = 0 trạng thái tại t
cho input_t trong input_sequence: Lặp lại các phần tử trình tự

đầu ra_t = f(đầu vào_t, trạng thái_t)
bang_t = đầu ra_t Đầu ra trước đó trở thành trạng thái cho lần lặp tiếp theo.

Hiểu các mạng thần kinh tái phát 197
Bạn thậm chí có thể bổ sung hàm f: việc chuyển đổi đầu vào và trạng thái thành đầu ra
sẽ được tham số hóa bởi hai ma trận, W và U, và một vectơ phân cực. Nó tương tự như quá
trình chuyển đổi được vận hành bởi một lớp kết nối dày đặc trong mạng chuyển tiếp.
Liệt kê 6.20 Mã giả chi tiết hơn cho RNN
state_t = 0 cho
input_t trong input_sequence:
đầu ra_t = kích hoạt (chấm (W, đầu vào_t) + dấu chấm (U, trạng thái_t) + b) trạng thái_t = đầu ra_t
Để làm cho những khái niệm này hoàn toàn rõ ràng, chúng ta hãy viết một triển khai Numpy ngây thơ về chuyển tiếp
của RNN đơn giản.
Liệt kê 6.21 Triển khai Numpy của một RNN đơn giản
Số dấu thời gian trong

Kích thước của không
chuỗi đầu vào
gian tính năng đầu vào
nhập numpy dưới dạng np Dữ liệu đầu vào: tiếng
ồn ngẫu nhiên vì lợi ích của
dấu thời gian = 100 tính
Kích thước của không
gian tính năng đầu ra ví dụ
năng đầu vào = 32 tính năng đầu
ra = 64
Trạng thái ban đầu: một
đầu vào = np.random.random((dấu thời gian, tính năng đầu vào))

vectơ hoàn toàn bằng không
state_t = np.zeros((output_features,))
W = np.random.random((tính năng đầu ra, tính năng đầu vào))

Tạo ma trận trọng
U = np.random.random((tính năng đầu ra, tính năng đầu ra)) b = np.random.random((tính năng đầu
số ngẫu nhiên
ra,))
input_t là một vectơ

kế tiếp_outputs = [] cho input_t trong
hình dạng (input_features,).
đầu vào:
output_t = np.tanh(np.dot(W, input_t) + np.dot(U, state_t) + b)
kế_outputs.append(output_t)
bang_t = đầu ra_t
final_output_sequence = np.concatenate(successive_outputs, axis=0)
Đầu ra cuối cùng là một thang đo hình

Lưu trữ đầu ra này trong một danh sách
dạng 2D (dấu thời gian, tính năng đầu ra).
Kết hợp đầu vào với trạng thái hiện tại

(đầu ra trước đó) để có được đầu ra Cập nhật trạng thái của
hiện tại mạng cho dấu thời gian tiếp theo
Đủ dễ dàng: tóm lại, RNN là một vòng lặp for sử dụng lại các số lượng được tính toán
trong lần lặp trước đó của vòng lặp, không có gì khác. Tất nhiên, có nhiều RNN khác
nhau phù hợp với định nghĩa này mà bạn có thể xây dựng—ví dụ này là một trong những
công thức RNN đơn giản nhất . RNN được đặc trưng bởi chức năng bước của chúng, chẳng
hạn như chức năng sau trong trường hợp này (xem hình 6.10):
output_t = np.tanh(np.dot(W, input_t) + np.dot(U, state_t) + b)

đầu ra t-1 đầu ra t đầu ra t+1
đầu ra_t =
kích hoạt (
... W•input_t + ...

Nhà nước t Trạng thái t+1
U•state_t + bo)
đầu vào t-1 đầu vào t nhập t+1
Hình 6.10 Một RNN đơn giản, không được kiểm soát theo thời gian
LƯU Ý Trong ví dụ này, đầu ra cuối cùng là một tenxơ 2D có dạng (dấu thời gian,
tính năng_đầu ra), trong đó mỗi dấu thời gian là đầu ra của vòng lặp tại thời điểm t.
Mỗi dấu thời gian t trong tenxơ đầu ra chứa thông tin về các dấu thời gian từ 0
đến t trong chuỗi đầu vào—về toàn bộ quá khứ. Vì lý do này, trong nhiều trường
hợp, bạn không cần chuỗi đầu ra đầy đủ này; bạn chỉ cần đầu ra cuối cùng (output_t
ở cuối vòng lặp), bởi vì nó đã chứa thông tin về toàn bộ chuỗi.
6.2.1 Lớp lặp lại trong Keras
Quá trình bạn vừa thực hiện một cách ngây thơ trong Numpy tương ứng với một lớp Keras thực
tế—lớp SimpleRNN :
từ keras.layers nhập SimpleRNN
Có một điểm khác biệt nhỏ: SimpleRNN xử lý hàng loạt trình tự, giống như tất cả các lớp
Keras khác, không phải một trình tự đơn lẻ như trong ví dụ về Numpy. Điều này có nghĩa là
nó nhận đầu vào có hình dạng (batch_size, timesteps, input_features), thay vì (timesteps,
input_features).
Giống như tất cả các lớp lặp lại trong Keras, SimpleRNN có thể được chạy ở hai chế độ
khác nhau: nó có thể trả về toàn bộ chuỗi đầu ra liên tiếp cho mỗi dấu thời gian ( hình
dạng mười 3D (batch_size, dấu thời gian, tính năng đầu ra)) hoặc chỉ đầu ra cuối cùng cho
từng chuỗi đầu vào (một tenxơ 2D có hình dạng (batch_size, output_features)). Hai chế độ
này được điều khiển bởi đối số hàm tạo return_sequences . Hãy xem một ví dụ sử dụng
SimpleRNN và chỉ trả về đầu ra ở dấu thời gian cuối cùng:
>>> from keras.models import Sequential >>> from

keras.layers import Embedding, SimpleRNN >>> model = Sequential()
>>> model.add(Embedding(10000, 32)) >>> model.add(SimpleRNN (32))
>>> model.summary()

________________________________________________________________
Lớp (loại) Hình dạng đầu ra Thông số #

================================================================= ==============
embedding_22 (Đang nhúng) (Không có, Không có, 32) 320000
________________________________________________________________
đơn giản hơnnn_10 (Đơn giảnRNN) (Không có, 32) 2080

================================================================= ==============
Tổng số tham số: 322.080
Thông số có thể huấn luyện: 322.080
Thông số không thể đào tạo: 0
Ví dụ sau trả về chuỗi trạng thái đầy đủ:
>>> model = Sequential() >>>
model.add(Embedding(10000, 32)) >>> model.add(SimpleRNN(32,
return_sequences=True)) >>> model.summary()
________________________________________________________________

================================================================= ==============
________________________________________________________________
đơn giản hơnnn_11 (SimpleRNN) (Không có, Không có, 32) 2080
================================================================= ==============
Tổng số tham số: 322.080
Đôi khi rất hữu ích khi xếp chồng một số lớp lặp lại lần lượt để tăng sức mạnh biểu
diễn của mạng. Trong cách thiết lập như vậy, bạn phải lấy tất cả các lớp trung gian
để trả về chuỗi đầu ra đầy đủ:
>>> model = Sequential() >>>
model.add(Embedding(10000, 32)) >>> model.add(SimpleRNN(32,
return_sequences=True)) >>> model.add(SimpleRNN(32, return_sequences =True)) >>>
model.add(SimpleRNN(32, return_sequences=True)) >>> model.add(SimpleRNN(32)) >>>
model.summary() Lớp cuối cùng chỉ trả về

đầu ra cuối cùng
________________________________________________________________

================================================================= ==============
________________________________________________________________
đơn giản hơnnn_12 (SimpleRNN) (Không có, Không có, 32) 2080
________________________________________________________________
đơn giản hơnnn_13 (Đơn giảnRNN) (Không có, Không có, 32) 2080
________________________________________________________________
đơn giản hơnnn_14 (Đơn giảnRNN) (Không có, Không có, 32) 2080
________________________________________________________________
đơn giản hơnnn_15 (Đơn giảnRNN) (Không có, 32) 2080

================================================================= ==============
Tổng thông số: 328.320

Bây giờ, hãy sử dụng một mô hình như vậy cho vấn đề phân loại đánh giá phim IMDB . Đầu tiên,
tiền xử lý dữ liệu.
Liệt kê 6.22 Chuẩn bị dữ liệu IMDB
từ keras.datasets nhập imdb từ trình tự nhập
keras.preprocessing
Số từ được coi là tính
năng
max_features = 10000 maxlen =
500
Cắt văn bản sau nhiều từ này (trong số
lô_size = 32
các từ phổ biến nhất trong max_features)
print('Đang tải dữ liệu...')
(input_train, y_train), (input_test, y_test) = imdb.load_data(

num_words=max_features)
print(len(input_train), 'đào tạo trình tự') print(len(input_test),
'kiểm tra trình tự')
print('Chuỗi pad (mẫu x thời gian)') input_train =
sequence.pad_sequences(input_train, maxlen=maxlen) input_test = sequence.pad_sequences(input_test,
maxlen=maxlen) print('hình dạng input_train:', input_train.shape) print( 'hình dạng input_test:',
input_test.shape)
Hãy đào tạo một mạng lặp lại đơn giản bằng cách sử dụng lớp Nhúng và lớp SimpleRNN .
Liệt kê 6.23 Huấn luyện mô hình với các lớp Embedding và SimpleRNN
từ keras.layers nhập dày đặc
model.add(Embedding(max_features, 32)) model.add(SimpleRNN(32))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy', dimensions=['acc']) history = model.fit(input_train, y_train,
epochs=10, batch_size=128, validation_split=0.2)
Bây giờ, hãy hiển thị sự mất mát và độ chính xác của đào tạo và xác thực (xem hình 6.11 và 6.12).
Liệt kê 6.24 Vẽ đồ thị kết quả
acc = history.history['acc'] val_acc =
history.history['val_acc'] loss = history.history['loss']
val_loss = history.history['val_loss']
kỷ nguyên = phạm vi (1, len (acc) + 1)
plt.plot(epochs, acc, 'bo', label='Act huấn luyện') plt.plot(epochs, val_acc,
'b', label='Acquy xác thực')

plt.title('Đào tạo và xác thực chính xác') plt.legend()
plt.figure()

val_loss, 'b', label='Mất quá trình xác thực') plt.title('Mất quá trình đào tạo và
plt.show()
Hình 6.11 Mất kiểm tra và đào tạo trên

IMDB với SimpleRNN
Hình 6.12 Độ chính xác của đào tạo và xác

thực trên IMDB với SimpleRNN
Xin nhắc lại, trong chương 3, cách tiếp cận ngây thơ đầu tiên đối với bộ dữ liệu này đã
giúp bạn đạt được độ chính xác kiểm tra là 88%. Thật không may, mạng lặp lại nhỏ này
không hoạt động tốt so với đường cơ sở này (độ chính xác xác thực chỉ 85%). Một phần
của vấn đề là đầu vào của bạn chỉ xem xét 500 từ đầu tiên, thay vì các chuỗi đầy đủ—do
đó, RNN có quyền truy cập vào ít thông tin hơn so với mô hình cơ sở trước đó. Phần còn lại của
vấn đề là SimpleRNN không xử lý tốt các chuỗi dài, chẳng hạn như văn bản.

Các loại lớp lặp lại khác hoạt động tốt hơn nhiều. Hãy xem xét một số lớp nâng cao hơn.
6.2.2 Hiểu các lớp LSTM và GRU
SimpleRNN không phải là lớp lặp lại duy nhất có sẵn trong Keras. Có hai cái khác: LSTM
và GRU. Trong thực tế, bạn sẽ luôn sử dụng một trong số này, vì SimpleRNN nói chung quá
đơn giản để sử dụng thực tế. SimpleRNN có một vấn đề lớn: mặc dù về mặt lý thuyết, nó
có thể giữ lại thông tin tại thời điểm t về các đầu vào đã thấy nhiều dấu thời gian
trước đó, nhưng trên thực tế, những phụ thuộc dài hạn như vậy là không thể học được.
Điều này là do vấn đề biến mất độ dốc, một hiệu ứng tương tự như những gì được quan sát
thấy với các mạng không hồi quy (mạng chuyển tiếp) có nhiều lớp sâu: khi bạn tiếp tục
thêm các lớp vào mạng, mạng cuối cùng trở nên không thể huấn luyện được. Lý do lý thuyết
cho hiệu ứng này đã được nghiên cứu bởi Hochreiter, Schmidhuber và Bengio vào đầu những
năm 1990.2 Các lớp LSTM và GRU được thiết kế để giải quyết vấn đề này.
Hãy xem xét lớp LSTM . Thuật toán Long Short-Term Memory (LSTM) cơ bản được phát
triển bởi Hochreiter và Schmidhuber vào năm 1997;3 đó là đỉnh cao của nghiên cứu của họ
về vấn đề độ dốc biến mất.
Lớp này là một biến thể của lớp SimpleRNN mà bạn đã biết; nó thêm một cách để mang
thông tin qua nhiều dấu thời gian. Hãy tưởng tượng một băng chuyền chạy song song với
chuỗi bạn đang xử lý. Thông tin từ trình tự có thể nhảy lên băng chuyền tại bất kỳ điểm
nào, được vận chuyển đến bước thời gian sau đó và nhảy ra, nguyên vẹn, khi bạn cần. Về
cơ bản, đây là những gì LSTM thực hiện: nó lưu thông tin cho lần sau, do đó ngăn các
tín hiệu cũ dần biến mất trong quá trình xử lý.
Để hiểu điều này một cách chi tiết, hãy bắt đầu từ ô SimpleRNN (xem hình 6.13).
Bởi vì bạn sẽ có nhiều ma trận trọng số, hãy lập chỉ mục các ma trận W và U trong ô có
chữ o (Wo và Uo) để xuất.
đầu ra_t =
kích hoạt (
... Wo•input_t + ...

Uo•state_t + bo)
Hình 6.13 Điểm bắt đầu của lớp LSTM : SimpleRNN
2
Ví dụ, hãy xem Yoshua Bengio, Patrice Simard và Paolo Frasconi, “Học các phụ thuộc dài hạn với độ dốc
dốc là khó,” Giao dịch IEEE trên mạng nơ-ron 5, số. 2 (1994).
3
Sepp Hochreiter và Jürgen Schmidhuber, “Long Short-Term Memory,” Neural Computation 9, không. 8 (1997).

Hãy thêm vào bức tranh này một luồng dữ liệu bổ sung mang thông tin qua các bước thời gian.
Gọi các giá trị của nó tại các dấu thời gian khác nhau là Ct, trong đó C là viết tắt của
carry. Thông tin này sẽ có tác động sau đối với ô: nó sẽ được kết hợp với kết nối đầu vào
và kết nối lặp lại (thông qua phép biến đổi dày đặc: tích vô hướng với ma trận trọng số
theo sau là phép cộng sai lệch và ứng dụng của hàm kích hoạt ) và nó sẽ ảnh hưởng đến trạng
thái được gửi đến dấu thời gian tiếp theo (thông qua hàm kích hoạt và phép toán nhân). Về
mặt khái niệm, luồng dữ liệu carry là một cách để điều chỉnh đầu ra tiếp theo và trạng thái
tiếp theo (xem hình 6.14). Đơn giản cho đến nay.
t-1 ct c t+1 thực hiện theo dõi
ct đầu ra_t = ct
kích hoạt (
Wo•input_t +
... ...
Uo•state_t +
Vo•c_t +
bo)
Hình 6.14 Chuyển từ SimpleRNN sang LSTM: thêm đường truyền tải
Bây giờ là sự tinh tế: cách tính giá trị tiếp theo của luồng dữ liệu mang. Nó liên quan đến
ba biến đổi riêng biệt. Cả ba đều có dạng một ô SimpleRNN :
y = kích hoạt (dấu chấm (trạng thái_t, U) + dấu chấm (đầu vào_t, W) + b)
Nhưng cả ba phép biến đổi đều có ma trận trọng số riêng mà bạn sẽ lập chỉ mục bằng các chữ
cái i, f và k. Đây là những gì bạn có cho đến nay (nó có vẻ hơi tùy tiện, nhưng hãy thông
cảm cho tôi).
Liệt kê 6.25 Chi tiết mã giả của kiến trúc LSTM (1/2)
output_t = activation(chấm(state_t, Uo) + chấm(input_t, Wo) + chấm(C_t, Vo) + bo)
i_t = kích hoạt(chấm(state_t, Ui) + chấm(input_t, Wi) + bi) f_t = kích hoạt(chấm(state_t,
Uf) + chấm(input_t, Wf) + bf) k_t = kích hoạt(chấm(state_t, Uk) + dấu chấm(input_t, Wk)
+ bk)
Bạn có được trạng thái mang mới ( c_t tiếp theo) bằng cách kết hợp i_t, f_t và k_t.
Liệt kê 6.26 Chi tiết mã giả của kiến trúc LSTM (2/2)
c_t+1 = i_t * k_t + c_t * f_t
Thêm phần này như trong hình 6.15. Và thế là xong. Không quá phức tạp - chỉ là một chút
phức tạp.

t-1 ct c t+1 thực hiện theo dõi

tính toán tính toán
Mới Mới
mang, thừa nhận mang, thừa nhận
ct đầu ra_t = ct
kích hoạt (
Wo•input_t +
... ...
Nhà nước t
Uo•state_t + Trạng thái t+1
Vo•c_t +
bo)
Hình 6.15 Cấu tạo của LSTM
Nếu bạn muốn hiểu triết học, bạn có thể giải thích ý nghĩa của từng hoạt động này. Chẳng hạn, bạn
có thể nói rằng nhân c_t và f_t là một cách để cố tình quên thông tin không liên quan trong luồng
dữ liệu mang theo. Trong khi đó, i_t và k_t cung cấp thông tin về hiện tại, cập nhật thông tin mới
cho đường đi của carry.
Nhưng vào cuối ngày, những diễn giải này không có nhiều ý nghĩa, bởi vì những hoạt động này thực
sự làm được xác định bởi nội dung của các trọng số tham số hóa chúng; và các trọng số được học theo
kiểu từ đầu đến cuối, bắt đầu lại với mỗi vòng huấn luyện, khiến cho không thể ghi nhận hoạt động
này hoặc hoạt động kia với một mục đích cụ thể. Thông số kỹ thuật của một ô RNN (như vừa được mô
tả) xác định không gian hình thành giả thuyết của bạn—không gian mà bạn sẽ tìm kiếm một cấu hình mô
hình tốt trong quá trình đào tạo—nhưng nó không xác định chức năng của ô đó; đó là tùy thuộc vào
trọng lượng tế bào.
Cùng một ô có trọng lượng khác nhau có thể làm những việc rất khác nhau. Vì vậy, quốc gia kết hợp
của các hoạt động tạo nên một ô RNN tốt hơn nên được hiểu là một tập hợp các ràng buộc đối với tìm
kiếm của bạn, chứ không phải là một thiết kế theo nghĩa kỹ thuật.
Đối với một nhà nghiên cứu, có vẻ như việc lựa chọn các ràng buộc như vậy—câu hỏi về cách triển
khai các tế bào RNN —tốt hơn là nên để các thuật toán tối ưu hóa (như thuật toán di truyền hoặc quy
trình học tăng cường) hơn là cho các kỹ sư con người. Và trong tương lai, đó là cách chúng tôi sẽ
xây dựng mạng lưới. Tóm lại: bạn không cần hiểu gì về kiến trúc cụ thể của một tế bào LSTM ; là một
con người, công việc của bạn không phải là hiểu nó. Chỉ cần ghi nhớ ý nghĩa của tế bào LSTM : cho
phép thông tin trong quá khứ được đưa vào lại sau đó, do đó giải quyết được vấn đề độ dốc biến mất.
6.2.3 Một ví dụ LSTM cụ thể trong Keras
Bây giờ, hãy chuyển sang những mối quan tâm thực tế hơn: bạn sẽ thiết lập một mô hình bằng cách sử
dụng một lớp LSTM và huấn luyện nó trên dữ liệu IMDB (xem hình 6.16 và 6.17). Mạng tương tự như
mạng với SimpleRNN vừa được trình bày. Bạn chỉ xác định kích thước đầu ra của lớp LSTM ; để lại mọi
đối số khác (có rất nhiều) tại Keras

mặc định. Keras có các giá trị mặc định tốt và mọi thứ hầu như sẽ luôn “hoạt động bình thường” mà bạn
không cần phải mất thời gian điều chỉnh các thông số bằng tay.
Liệt kê 6.27 Sử dụng lớp LSTM trong Keras
từ keras.layers nhập LSTM
model.add(Embedding(max_features, 32))
model.add(LSTM(32)) model.add(Dense(1,
activation='sigmoid'))
dimensions=['acc'])
history = model.fit(input_train, y_train, epochs=10,
batch_size=128,
Hình 6.16 Mất kiểm tra và đào tạo trên

IMDB với LSTM
Hình 6.17 Độ chính xác của đào tạo và

xác thực trên IMDB với LSTM

Lần này, bạn đạt được độ chính xác xác thực lên tới 89%. Không tệ: chắc chắn là tốt hơn nhiều
so với mạng SimpleRNN —điều đó phần lớn là do LSTM ít gặp vấn đề về độ dốc biến mất hơn nhiều—
và tốt hơn một chút so với cách tiếp cận được kết nối đầy đủ ở chương 3, mặc dù bạn đang xem
xét ít dữ liệu hơn so với trong chương 3 Chương 3.
Bạn đang cắt ngắn các chuỗi sau 500 dấu thời gian, trong khi ở chương 3, bạn đang xem xét các
chuỗi đầy đủ.
Nhưng kết quả này không phải là bước đột phá đối với cách tiếp cận chuyên sâu về tính toán
như vậy. Tại sao LSTM không hoạt động tốt hơn? Một lý do là bạn đã không nỗ lực điều chỉnh các
siêu tham số chẳng hạn như thứ nguyên nhúng hoặc thứ nguyên đầu ra LSTM . Một cái khác có thể
là thiếu chính quy. Nhưng thành thật mà nói, lý do chính là việc phân tích cấu trúc toàn cầu,
dài hạn của các bài đánh giá ( LSTM giỏi về lĩnh vực gì) không hữu ích cho vấn đề phân tích tình
cảm. Một vấn đề cơ bản như vậy được giải quyết tốt bằng cách xem những từ nào xuất hiện trong
mỗi bài đánh giá và với tần suất như thế nào. Đó là những gì phương pháp kết nối đầy đủ đầu tiên
xem xét. Nhưng có nhiều vấn đề xử lý ngôn ngữ tự nhiên khó khăn hơn nhiều, nơi sức mạnh của LSTM
sẽ trở nên rõ ràng: đặc biệt là trả lời câu hỏi và dịch máy.
6.2.4 Kết thúc

Bây giờ bạn đã hiểu như sau:
RNN là gì và chúng hoạt động như thế
nào LSTM là gì và tại sao nó hoạt động tốt hơn trên các chuỗi dài so với RNN đơn
giản Cách sử dụng các lớp Keras RNN để xử lý dữ liệu chuỗi
Tiếp theo, chúng ta sẽ xem xét một số tính năng nâng cao hơn của RNN, những tính năng này có
thể giúp bạn tận dụng tối đa các mô hình trình tự học sâu của mình.

Sử dụng nâng cao các mạng thần kinh tái phát 207
6.3 Sử dụng nâng cao các mạng thần kinh tái phát
Trong phần này, chúng ta sẽ xem xét ba kỹ thuật nâng cao để cải thiện hiệu suất và sức
mạnh tổng quát hóa của các mạng thần kinh hồi quy. Đến cuối phần này, bạn sẽ biết hầu hết
những điều cần biết về cách sử dụng mạng lặp lại với Keras. Chúng tôi sẽ trình bày cả ba
khái niệm về vấn đề dự báo nhiệt độ, trong đó bạn có quyền truy cập vào chuỗi thời gian của
các điểm dữ liệu đến từ các cảm biến được lắp đặt trên nóc tòa nhà, chẳng hạn như nhiệt độ,
áp suất không khí và độ ẩm mà bạn sử dụng để dự đoán nhiệt độ sẽ là bao nhiêu trong 24 giờ
sau điểm dữ liệu cuối cùng. Đây là một vấn đề khá khó khăn, minh họa cho nhiều khó khăn phổ
biến gặp phải khi làm việc với chuỗi thời gian.
Chúng tôi sẽ đề cập đến các kỹ thuật
sau: Bỏ học lặp lại—Đây là một cách cụ thể, tích hợp sẵn để sử dụng bỏ học để chống
lại hiện tượng overfit trong các lớp lặp lại. Xếp chồng các lớp lặp lại—Điều này
làm tăng khả năng biểu diễn của mạng (với chi phí tải tính toán cao hơn).
Các lớp lặp lại hai chiều —Những lớp này trình bày cùng một thông tin cho mạng lặp
lại theo các cách khác nhau, tăng độ chính xác và giảm thiểu các vấn đề về quên.
6.3.1 Bài toán dự báo nhiệt độ

Cho đến bây giờ, dữ liệu trình tự duy nhất mà chúng tôi đề cập là dữ liệu văn bản, chẳng
hạn như bộ dữ liệu IMDB và bộ dữ liệu Reuters. Nhưng dữ liệu trình tự được tìm thấy trong
nhiều vấn đề hơn là chỉ xử lý ngôn ngữ. Trong tất cả các ví dụ trong phần này, bạn sẽ chơi
với bộ dữ liệu chuỗi thời gian thời tiết được ghi lại tại Trạm thời tiết ở Viện Max Planck
bài giảng về Hóa địa sinh học ở Jena, Đức.4

Trong bộ dữ liệu này, 14 đại lượng khác nhau (nhiệt độ không khí, áp suất khí quyển,
độ ẩm, hướng gió, v.v.) được ghi lại cứ sau 10 phút, trong nhiều năm. Dữ liệu gốc có từ
năm 2003, nhưng ví dụ này chỉ giới hạn ở dữ liệu từ năm 2009–2016. Bộ dữ liệu này là hoàn
hảo để học cách làm việc với chuỗi thời gian số. Bạn sẽ sử dụng nó để xây dựng một mô hình
lấy một số dữ liệu đầu vào từ quá khứ gần đây (các điểm dữ liệu có giá trị trong vài ngày)
và dự đoán nhiệt độ không khí trong 24 giờ trong tương lai.
Tải về và giải nén dữ liệu như sau:
cd ~/Tải xuống
mkdir jena_climate cd
jena_climate wget https://
s3.amazonaws.com/keras-datasets/jena_climate_2009_2016.csv.zip giải nén jena_climate_2009_2016.csv.zip
Hãy nhìn vào dữ liệu.
4
Olaf Kolle, www.bgc-jena.mpg.de/wetter.

Liệt kê 6.28 Kiểm tra dữ liệu của bộ dữ liệu thời tiết Jena
nhập hệ điều hành
data_dir = '/users/fchollet/Downloads/jena_climate' fname = os.path.join(data_dir,
'jena_climate_2009_2016.csv')
f = open(fname) data =
f.read()
f.đóng()
lines = data.split('\n') header =

lines[0].split(',') lines = lines[1:]
in(tiêu đề)
in(len(dòng))
Điều này tạo ra tổng số 420.551 dòng dữ liệu (mỗi dòng là một dấu thời gian: bản ghi ngày và 14 giá trị
liên quan đến thời tiết), cũng như tiêu đề sau:
["Ngày Giờ", "p
(mbar)", "T
(degC)", "Tpot
(K)", "Tdew
(degC)", "rh (%)",
"VPmax (mbar)",
"VPact (mbar)", "VPdef

(mbar)", "sh (g/kg)",
"H2OC (mmol/mol)", "rho
(g/m**3)", "wv (m/s)" ,

"tối đa wv (m/s)", "wd (độ)"]
Bây giờ, hãy chuyển đổi tất cả 420.551 dòng dữ liệu thành một mảng Numpy.
Liệt kê 6.29 Phân tích cú pháp dữ liệu
float_data = np.zeros((len(lines), len(header) - 1)) for i, line in

enumerate(lines): values = [float(x) for x in line.split(',')[1 :]] float_data[i, :]
= giá trị
Ví dụ, đây là biểu đồ nhiệt độ (tính bằng độ C) theo thời gian (xem hình 6.18). Trên biểu đồ này, bạn có
thể thấy rõ tính chu kỳ hàng năm của nhiệt độ.

Liệt kê 6.30 Vẽ sơ đồ chuỗi thời gian nhiệt độ
từ matplotlib nhập pyplot dưới dạng plt
temp = float_data[:, 1] <1> nhiệt độ (tính bằng độ C) plt.plot(range(len(temp)), temp)
Hình 6.18 Nhiệt độ trong toàn

bộ phạm vi thời gian của tập dữ
liệu (ºC)
Đây là một biểu đồ hẹp hơn của dữ liệu nhiệt độ trong 10 ngày đầu tiên (xem hình 6.19).
Vì dữ liệu được ghi 10 phút một lần nên bạn nhận được 144 điểm dữ liệu mỗi ngày.
Liệt kê 6.31 Vẽ biểu đồ 10 ngày đầu tiên của chuỗi thời gian nhiệt độ
plt.plot(phạm vi(1440), tạm thời[:1440])
Hình 6.19 Nhiệt độ trong 10

ngày đầu tiên của tập dữ liệu
(ºC)

Trên biểu đồ này, bạn có thể thấy chu kỳ hàng ngày, đặc biệt rõ ràng trong 4 ngày qua. Cũng lưu ý
rằng khoảng thời gian 10 ngày này phải đến từ một tháng mùa đông khá lạnh.
Nếu bạn đang cố gắng dự đoán nhiệt độ trung bình cho tháng tới dựa trên dữ liệu của một vài
tháng trong quá khứ, thì vấn đề sẽ trở nên dễ dàng, do độ chính xác của dữ liệu trong khoảng thời
gian theo năm đáng tin cậy. Nhưng nhìn vào dữ liệu theo thang ngày, nhiệt độ có vẻ hỗn loạn hơn
rất nhiều. Chuỗi thời gian này có thể dự đoán được ở quy mô hàng ngày không? Hãy cùng tìm hiểu.
6.3.2 Chuẩn bị dữ liệu
Công thức chính xác của vấn đề sẽ như sau: dữ liệu được cung cấp từ các dấu thời gian nhìn lại (một
dấu thời gian là 10 phút) và lấy mẫu từng bước các dấu thời gian, bạn có thể dự đoán nhiệt độ trong
các dấu thời gian trễ không? Bạn sẽ sử dụng các giá trị tham số sau:
lookback = 720—Các quan sát sẽ lùi lại sau 5 ngày. bước
= 6—Các quan sát sẽ được lấy mẫu tại một điểm dữ liệu mỗi giờ. delay = 144—Các
mục tiêu sẽ là 24 giờ trong tương lai.
Để bắt đầu, bạn cần làm hai việc:
Tiền xử lý dữ liệu thành định dạng mà mạng thần kinh có thể nhập vào. Điều này thật dễ dàng:
dữ liệu đã ở dạng số, vì vậy bạn không cần thực hiện bất kỳ thao tác vector hóa nào. Nhưng
mỗi chuỗi thời gian trong dữ liệu ở một thang đo khác nhau (ví dụ: nhiệt độ thường nằm
trong khoảng từ -20 đến +30, nhưng áp suất khí quyển, được đo bằng mbar, là khoảng 1.000).
Bạn sẽ chuẩn hóa từng chuỗi thời gian một cách độc lập để tất cả chúng đều nhận các giá trị
nhỏ trên cùng một thang đo.
Viết một trình tạo Python lấy mảng dữ liệu float hiện tại và tạo ra các lô dữ liệu từ quá
khứ gần đây, cùng với nhiệt độ mục tiêu trong tương lai. Bởi vì các mẫu trong tập dữ liệu
rất dư thừa (mẫu N và mẫu N + 1 sẽ có hầu hết các dấu thời gian chung), sẽ rất lãng phí nếu
phân bổ rõ ràng mọi mẫu. Thay vào đó, bạn sẽ nhanh chóng tạo các mẫu bằng cách sử dụng dữ
liệu gốc.
Bạn sẽ xử lý trước dữ liệu bằng cách trừ đi giá trị trung bình của từng chuỗi thời gian và chia cho
độ lệch chuẩn. Bạn sẽ sử dụng 200.000 dấu thời gian đầu tiên làm dữ liệu huấn luyện, vì vậy chỉ
tính toán giá trị trung bình và độ lệch chuẩn trên phần dữ liệu này.
Liệt kê 6.32 Chuẩn hóa dữ liệu
mean = float_data[:200000].mean(axis=0)
float_data -= mean std =
float_data[:200000].std(axis=0) float_data /=
std
Liệt kê 6.33 cho thấy trình tạo dữ liệu mà bạn sẽ sử dụng. Nó tạo ra một bộ (mẫu, mục tiêu), trong
đó mẫu là một lô dữ liệu đầu vào và mục tiêu là mảng nhiệt độ mục tiêu tương ứng. Nó có các đối số
sau:

data—Mảng ban đầu của dữ liệu dấu phẩy động mà bạn đã chuẩn hóa trong danh sách
6.32. nhìn lại— Dữ liệu đầu vào sẽ quay lại bao nhiêu bước thời gian. trì hoãn
— Mục tiêu nên có bao nhiêu bước thời gian trong tương lai. min_index và max_index
—Các chỉ số trong mảng dữ liệu phân định các bước thời gian để vẽ từ đó. Điều này hữu
ích để giữ một phân đoạn dữ liệu để xác thực và một phân đoạn khác để thử nghiệm.
xáo trộn—Có nên xáo trộn các mẫu hay vẽ chúng theo thứ tự thời gian.
batch_size—Số lượng mẫu mỗi đợt. bước—Khoảng thời gian, theo dấu thời gian,
tại đó bạn lấy mẫu dữ liệu. Bạn sẽ đặt nó thành 6 in
để vẽ một điểm dữ liệu mỗi giờ.
Liệt kê 6.33 Các mẫu chuỗi thời gian tạo ra năng suất và các mục tiêu của chúng
trình tạo def(data, lookback, delay, min_index, max_index, shuffle=False, batch_size=128,

step=6): nếu max_index là Không có: max_index = len(data) - delay -
1 i = min_index + lookback while 1: nếu xáo trộn: rows = np.random.randint(
min_index + lookback, max_index, size=batch_size)

khác:
nếu i + batch_size >= max_index: i = min_index

+ lookback
hàng = np.arange(i, min(i + batch_size, max_index)) i += len(hàng)
mẫu = np.zeros((len(hàng),
nhìn lại // bước,
data.shape[-1]))
target = np.zeros((len(hàng),)) cho j, hàng trong
liệt kê(hàng): indices = range(rows[j] - lookback,
rows[j], step) samples[j] = data[indices ] target[j] = data[rows[j] + delay]
[1] sản lượng mẫu, mục tiêu
Bây giờ, hãy sử dụng hàm tạo trừu tượng để khởi tạo ba trình tạo: một để đào tạo, một để
xác thực và một để kiểm tra. Mỗi phần sẽ xem xét các phân đoạn thời gian khác nhau của dữ
liệu gốc: trình tạo đào tạo xem xét 200.000 bước thời gian đầu tiên, trình tạo xác thực
xem xét 100.000 bước tiếp theo và trình tạo thử nghiệm xem xét phần còn lại.
Liệt kê 6.34 Chuẩn bị các trình tạo đào tạo, xác nhận và kiểm tra
nhìn lại = 1440
bước = 6 độ
trễ = 144
batch_size = 128

train_gen = máy phát điện (float_data,

lookback=lookback,
delay=delay,
min_index=0,
max_index=200000,
shuffle=True, step=step,
batch_size=batch_size)
val_gen = trình tạo (float_data,

lookback=lookback,
delay=delay,
min_index=200001,
max_index=300000,
step=step,
test_gen = trình tạo (float_data,
lookback=lookback,
delay=delay,
Có bao nhiêu bước để vẽ từ
min_index=300001,
val_gen để xem toàn bộ bộ
max_index=None, xác thực
step=step,
val_steps = (300000 - 200001 - nhìn lại) Có bao nhiêu bước để

vẽ từ test_gen để xem
test_steps = (len(float_data) - 300001 - nhìn lại) toàn bộ bộ thử nghiệm
6.3.3 Đường cơ sở thông thường, không học máy
Trước khi bạn bắt đầu sử dụng các mô hình học sâu hộp đen để giải quyết vấn đề dự đoán
nhiệt độ, hãy thử một cách tiếp cận đơn giản, thông thường. Nó sẽ đóng vai trò kiểm tra độ
chính xác và nó sẽ thiết lập một đường cơ sở mà bạn sẽ phải vượt qua để chứng minh tính hữu
ích của các mô hình máy học tiên tiến hơn. Những đường cơ sở thông thường như vậy có thể
hữu ích khi bạn đang tiếp cận một vấn đề mới mà chưa có giải pháp nào được biết đến (chưa).
Một ví dụ kinh điển là nhiệm vụ phân loại không cân bằng, trong đó một số lớp phổ biến hơn
nhiều so với các lớp khác. Nếu tập dữ liệu của bạn chứa 90% phiên bản của loại A và 10%
phiên bản của loại B, thì cách tiếp cận thông thường đối với nhiệm vụ phân loại là luôn dự
đoán “A” khi được trình bày với một mẫu mới. Một bộ phân loại như vậy có độ chính xác tổng
thể là 90% và do đó, bất kỳ phương pháp tiếp cận dựa trên học tập nào cũng phải đánh bại
điểm số 90% này để chứng minh tính hữu dụng. Đôi khi, những đường cơ sở cơ bản như vậy có
thể tỏ ra khó đánh bại một cách đáng ngạc nhiên.
Trong trường hợp này, chuỗi thời gian nhiệt độ có thể được coi là liên tục một cách an
toàn (nhiệt độ ngày mai có khả năng gần với nhiệt độ hôm nay) cũng như định kỳ với khoảng
thời gian hàng ngày. Do đó, một cách tiếp cận thông thường là luôn dự đoán rằng nhiệt độ
trong 24 giờ kể từ bây giờ sẽ bằng với nhiệt độ ngay bây giờ.
Hãy đánh giá phương pháp này, sử dụng chỉ số sai số tuyệt đối trung bình (MAE) :
np.mean(np.abs(preds - target))

Đây là vòng đánh giá.
Liệt kê 6.35 Tính toán MAE cơ sở thông thường
không đánh giá_naive_method():

batch_maes = [] cho
bước trong phạm vi (val_steps):

mẫu, mục tiêu = next(val_gen) preds = mẫu[:, -1,
1] mae = np.mean(np.abs(preds - target))
batch_maes.append(mae) print(np.mean(batch_maes))
đánh giá_naive_method()
Điều này mang lại MAE là 0,29. Bởi vì dữ liệu nhiệt độ đã được chuẩn hóa để tập trung vào 0
và có độ lệch chuẩn là 1, nên con số này không thể đoán trước được ngay lập tức. Nó có nghĩa
là sai số tuyệt đối trung bình là 0,29 × temperature_std độ C: 2,57˚C.
Liệt kê 6.36 Chuyển đổi MAE trở lại lỗi Celsius
celsius_mae = 0,29 * tiêu chuẩn [1]
Đó là một lỗi tuyệt đối trung bình khá lớn. Bây giờ, trò chơi là sử dụng kiến thức học sâu
của bạn để làm tốt hơn.
6.3.4 Phương pháp học máy cơ bản
Cũng giống như việc thiết lập một cơ sở thông thường trước khi thử các phương pháp học máy,
việc thử các mô hình máy học đơn giản, rẻ tiền (chẳng hạn như các mạng nhỏ, được kết nối
chặt chẽ) trước khi xem xét các mô hình phức tạp và tốn kém về mặt tính toán cũng rất hữu
ích. chẳng hạn như RNN. Đây là cách tốt nhất để đảm bảo rằng bất kỳ sự phức tạp nào mà bạn
ném vào vấn đề là hợp pháp và mang lại lợi ích thực sự.
Danh sách sau đây cho thấy một mô hình được kết nối đầy đủ bắt đầu bằng cách làm phẳng
dữ liệu và sau đó chạy nó qua hai lớp Mật độ . Lưu ý việc thiếu chức năng kích hoạt trên
lớp Mật độ cao cuối cùng , điển hình cho vấn đề hồi quy. Bạn sử dụng MAE là lỗ.
Bởi vì bạn đánh giá trên cùng một dữ liệu và với cùng một số liệu chính xác mà bạn đã thực
hiện với phương pháp tiếp cận thông thường, kết quả sẽ có thể so sánh trực tiếp.
Liệt kê 6.37 Huấn luyện và đánh giá một mô hình kết nối dày đặc
từ máy ảnh.models nhập Tuần tự từ máy ảnh nhập lớp

từ máy ảnh.optimizers nhập RMSprop
model.add(layers.Flatten(input_shape=(lookback // step, float_data.shape[-1]))) model.add(layers.Dense(32,
activation='relu')) model. thêm (lớp.Dense (1))

model.compile(optimizer=RMSprop(), loss='mae') history =

model.fit_generator(train_gen, step_per_epoch=500, epochs=20,
validation_data=val_gen,
validation_steps=val_steps)
Hãy hiển thị các đường cong tổn thất để xác nhận và đào tạo (xem hình 6.20).
Liệt kê 6.38 Vẽ kết quả
loss = history.history['loss'] val_loss =
history.history['val_loss']
kỷ nguyên = phạm vi (1, len (mất) + 1)
plt.figure()
val_loss, 'b', label='Mất quá trình xác thực') plt.title('Mất quá trình đào tạo và xác
thực') plt .huyền thoại()
plt.show()
Hình 6.20 Mất kiểm chứng và đào tạo trong

nhiệm vụ dự báo nhiệt độ Jena với một mạng
kết nối đơn giản, dày đặc
Một số tổn thất xác thực gần với đường cơ sở không học, nhưng không đáng tin cậy.
Điều này cho thấy giá trị của việc có đường cơ sở này ngay từ đầu: hóa ra không dễ để vượt
trội hơn. Ý thức chung của bạn chứa rất nhiều thông tin có giá trị mà mô hình học máy
không có quyền truy cập.
Bạn có thể thắc mắc, nếu tồn tại một mô hình đơn giản, hoạt động tốt để đi từ dữ liệu
đến mục tiêu (đường cơ sở thông thường), thì tại sao mô hình mà bạn đang đào tạo không tìm
ra và cải thiện mô hình đó? Bởi vì giải pháp đơn giản này không phải là thứ mà cơ sở đào
tạo của bạn đang tìm kiếm. Không gian của các mô hình mà bạn đang tìm kiếm giải pháp trong
đó—nghĩa là không gian giả thuyết của bạn—là không gian của tất cả các mạng hai lớp có thể
có với cấu hình mà bạn đã xác định. Các mạng này đã khá phức tạp. Khi bạn đang tìm kiếm một

giải pháp với một không gian gồm các mô hình phức tạp, thì đường cơ sở đơn giản, hoạt động tốt
có thể không học được, ngay cả khi về mặt kỹ thuật, nó là một phần của không gian giả thuyết.
Đó là một hạn chế khá lớn của học máy nói chung: trừ khi thuật toán học được mã hóa cứng để
tìm kiếm một loại mô hình đơn giản cụ thể, việc học tham số đôi khi có thể không tìm ra giải
pháp đơn giản cho một vấn đề đơn giản.
6.3.5 Đường cơ sở lặp lại đầu tiên
Cách tiếp cận được kết nối đầy đủ đầu tiên không hoạt động tốt, nhưng điều đó không có nghĩa
là học máy không thể áp dụng cho vấn đề này. Cách tiếp cận trước tiên làm phẳng chuỗi thời
gian, loại bỏ khái niệm thời gian khỏi dữ liệu đầu vào. Thay vào đó, chúng ta hãy xem dữ liệu
như bản chất của nó: một chuỗi, trong đó quan hệ nhân quả và trật tự là quan trọng. Bạn sẽ thử
mô hình xử lý trình tự lặp lại—mô hình này phải phù hợp hoàn hảo cho dữ liệu trình tự đó, chính
xác là vì mô hình này khai thác thứ tự thời gian của các điểm dữ liệu, không giống như cách
tiếp cận đầu tiên.
Thay vì lớp LSTM được giới thiệu trong phần trước, bạn sẽ sử dụng lớp GRU , được phát
triển bởi Chung et al. trong năm 2014.5 Các lớp đơn vị hồi quy có cổng (GRU) hoạt động theo
nguyên tắc giống như LSTM, nhưng chúng hơi được sắp xếp hợp lý và do đó rẻ hơn để chạy (mặc dù
chúng có thể không có nhiều sức mạnh đại diện như LSTM). Sự đánh đổi giữa mức độ đắt đỏ của
tính toán và sức mạnh đại diện được thấy ở khắp mọi nơi trong học máy.
Liệt kê 6.39 Đào tạo và đánh giá mô hình dựa trên GRU
từ máy ảnh.models nhập Tuần tự từ máy ảnh nhập lớp từ

máy ảnh.optimizers nhập RMSprop
model.add(layers.GRU(32, input_shape=(None, float_data.shape[-1]))) model.add(layers.Dense(1))

Hình 6.21 cho thấy kết quả. Tốt hơn nhiều! Bạn có thể đánh bại đáng kể đường cơ sở thông
thường, thể hiện giá trị của máy học cũng như tính ưu việt của mạng lặp lại so với mạng dày
đặc làm phẳng trình tự trong loại tác vụ này.
5
Junyoung Chung và cộng sự, “Đánh giá thực nghiệm các mạng thần kinh tái phát có kiểm soát trên mô hình trình tự,”
Hội nghị về Hệ thống Xử lý Thông tin Thần kinh (2014), https://arxiv.org/abs/1412.3555.

Hình 6.21 Mất kiểm chứng và đào tạo

trong nhiệm vụ dự báo nhiệt độ Jena bằng
GRU
MAE xác thực mới là ~0,265 (trước khi bạn bắt đầu khớp quá mức đáng kể) chuyển thành sai
số tuyệt đối trung bình là 2,35˚C sau khi không chuẩn hóa. Đó là mức tăng đáng kể so với
sai số ban đầu là 2,57˚C, nhưng có lẽ bạn vẫn còn một chút lợi nhuận để cải thiện.
6.3.6 Sử dụng bỏ học định kỳ để chống lại việc trang bị quá mức
Rõ ràng là từ các đường cong đào tạo và xác thực rằng mô hình đang bị quá khớp: các tổn
thất trong đào tạo và xác nhận bắt đầu phân kỳ đáng kể sau một vài kỷ nguyên. Bạn đã quen
thuộc với một kỹ thuật cổ điển để chống lại hiện tượng này: dropout, loại bỏ ngẫu nhiên
các đơn vị đầu vào của một lớp để phá vỡ các mối quan hệ ngẫu nhiên trong dữ liệu đào tạo
mà lớp tiếp xúc. Nhưng làm thế nào để áp dụng dropout một cách chính xác trong các mạng lặp
lại không phải là một câu hỏi tầm thường. Từ lâu, người ta đã biết rằng việc áp dụng bỏ học
trước một lớp lặp lại sẽ cản trở việc học hơn là giúp ích cho việc chính quy hóa. Vào năm
2015, Yarin Gal, như một phần của luận án tiến sĩ về học sâu Bayesian,6 đã xác định cách
thích hợp để sử dụng dropout với mạng lặp lại: cùng một mặt nạ dropout (cùng một mẫu đơn
vị bị drop) nên được áp dụng ở mọi bước. , thay vì mặt nạ bỏ học thay đổi ngẫu nhiên từ
dấu thời gian này sang dấu thời gian khác.
Hơn nữa, để chuẩn hóa các biểu diễn được hình thành bởi các cổng lặp lại của các lớp như
GRU và LSTM, nên áp dụng mặt nạ bỏ qua liên tục theo thời gian cho các kích hoạt lặp lại
bên trong của lớp ( mặt nạ bỏ qua lặp lại ). Việc sử dụng cùng một mặt nạ bỏ học ở mọi dấu
thời gian cho phép mạng lan truyền chính xác lỗi học tập của nó theo thời gian; mặt nạ bỏ
học ngẫu nhiên tạm thời sẽ phá vỡ tín hiệu lỗi này và có hại cho quá trình học tập.
Yarin Gal đã thực hiện nghiên cứu của mình bằng cách sử dụng Keras và giúp xây dựng cơ
chế này trực tiếp vào các lớp lặp lại của Keras. Mỗi lớp lặp lại trong Keras có hai đối số
liên quan đến bỏ học: bỏ học, số float chỉ định tỷ lệ bỏ học cho các đơn vị đầu vào của lớp,
6
Xem Yarin Gal, “Uncertainty in Deep Learning (PhD Thesis),” ngày 13 tháng 10 năm 2016, http://mlg.eng.cam.ac.uk/
yarin/blog_2248.html.

và reccurrent_dropout, chỉ định tỷ lệ bỏ học của các đơn vị lặp lại. Hãy thêm trường hợp bỏ
học và bỏ học định kỳ vào lớp GRU và xem cách làm như vậy tác động đến tình trạng overfit.
Bởi vì các mạng được chuẩn hóa với tình trạng bỏ học luôn mất nhiều thời gian hơn để hội tụ
đầy đủ, nên bạn sẽ đào tạo mạng với số lượng kỷ nguyên gấp đôi.
Liệt kê 6.40 Đào tạo và đánh giá mô hình dựa trên GRU chính quy hóa bỏ học

model.add(layers.GRU(32, dropout=0.2,
recurrent_dropout=0.2,
input_shape=(None, float_data.shape[-1])))
model.add(layers.Dense(1))

Hình 6.22 cho thấy kết quả. Sự thành công! Bạn không còn trang bị quá mức trong 30 kỷ nguyên
đầu tiên. Nhưng mặc dù bạn có điểm đánh giá ổn định hơn, nhưng điểm tốt nhất của bạn không
thấp hơn nhiều so với trước đây.
Hình 6.22 Mất khả năng đào tạo và xác

thực đối với nhiệm vụ dự báo nhiệt độ
Jena với GRU được chuẩn hóa bỏ học
6.3.7 Xếp chồng các lớp lặp lại
Bởi vì bạn không còn trang bị quá mức nhưng dường như đã gặp phải nút thắt cổ chai về hiệu
suất, bạn nên xem xét việc tăng dung lượng của mạng. Nhớ lại mô tả về quy trình học máy phổ
quát: nói chung, bạn nên tăng dung lượng mạng của mình cho đến khi trang bị quá mức trở thành
trở ngại chính (giả sử

bạn đã thực hiện các bước cơ bản để giảm thiểu việc trang bị thừa, chẳng hạn như sử dụng bỏ học).
Miễn là bạn không trang bị quá nhiều, thì có khả năng bạn đang ở dưới khả năng.
Việc tăng dung lượng mạng thường được thực hiện bằng cách tăng số lượng đơn vị trong các lớp
hoặc thêm nhiều lớp hơn. Xếp chồng lớp lặp lại là một cách cổ điển để xây dựng các mạng lặp lại
mạnh mẽ hơn: ví dụ: thứ hiện đang cung cấp năng lượng cho thuật toán Google Dịch là một chồng gồm
bảy lớp LSTM lớn —rất lớn.
Để xếp các lớp lặp lại chồng lên nhau trong Keras, tất cả các lớp trung gian phải trả về chuỗi
đầu ra đầy đủ của chúng (một tenxơ 3D) thay vì đầu ra của chúng ở dấu thời gian cuối cùng. Điều
này được thực hiện bằng cách chỉ định return_sequences=True.
Liệt kê 6.41 Huấn luyện và đánh giá mô hình GRU xếp chồng, chính quy hóa bỏ học

model.add(layers.GRU(32, dropout=0.1,
recurrent_dropout=0.5,
return_sequences=True,
input_shape=(None, float_data.shape[-1]))) model.add(layers.GRU( 64,
activation='relu', dropout=0.1, reccurrent_dropout=0.5))

Hình 6.23 cho thấy kết quả. Bạn có thể thấy rằng lớp được thêm vào sẽ cải thiện kết quả một chút,
mặc dù không đáng kể. Bạn có thể rút ra hai kết luận:
Bởi vì bạn vẫn không trang bị quá mức quá tệ, nên bạn có thể tăng kích thước các lớp của
mình một cách an toàn để tìm kiếm cải thiện tình trạng mất xác thực. Điều này có một chi
phí tính toán không đáng kể, mặc dù.
Việc thêm một lớp không giúp ích gì bởi một yếu tố quan trọng, vì vậy bạn có thể thấy lợi
nhuận giảm dần từ việc tăng dung lượng mạng vào thời điểm này.

Hình 6.23 Mất kiểm chứng và đào tạo đối

với tác vụ dự báo nhiệt độ Jena với
mạng GRU xếp chồng
6.3.8 Sử dụng RNN hai chiều
Kỹ thuật cuối cùng được giới thiệu trong phần này được gọi là RNN hai chiều . RNN hai chiều
là một biến thể RNN phổ biến có thể mang lại hiệu suất cao hơn RNN thông thường trong một số
tác vụ nhất định. Nó thường được sử dụng trong xử lý ngôn ngữ tự nhiên—bạn có thể gọi nó là
con dao học sâu của Quân đội Thụy Sĩ để xử lý ngôn ngữ tự nhiên.
Các RNN đáng chú ý là phụ thuộc vào thứ tự hoặc phụ thuộc vào thời gian: chúng xử lý các
dấu thời gian của chuỗi đầu vào theo thứ tự và việc xáo trộn hoặc đảo ngược các dấu thời gian
có thể thay đổi hoàn toàn các biểu diễn mà RNN trích xuất từ chuỗi. Đây chính xác là lý do
chúng thực hiện tốt các bài toán mà thứ tự có ý nghĩa, chẳng hạn như bài toán dự báo nhiệt độ.
RNN hai chiều khai thác độ nhạy thứ tự của RNN: nó bao gồm việc sử dụng hai RNN thông thường,
chẳng hạn như các lớp GRU và LSTM mà bạn đã quen thuộc, mỗi lớp xử lý trình tự đầu vào theo
một hướng (theo trình tự thời gian và ngược thời gian), và sau đó hợp nhất các biểu diễn của
chúng. Bằng cách xử lý một chuỗi theo cả hai cách, RNN hai chiều có thể nắm bắt các mẫu mà RNN
một chiều có thể bỏ qua .
Đáng chú ý, thực tế là các lớp RNN trong phần này đã xử lý các trình tự theo trình tự thời
gian (các dấu thời gian cũ hơn trước) có thể là một quyết định tùy ý. Ít nhất, đó là một quyết
định mà chúng tôi đã không cố gắng đặt câu hỏi cho đến nay. Chẳng hạn, các RNN có thể hoạt
động đủ tốt nếu chúng xử lý các chuỗi đầu vào theo thứ tự ngược thời gian (các dấu thời gian
mới hơn trước) không? Hãy thử điều này trong thực tế và xem điều gì sẽ xảy ra. Tất cả những
gì bạn cần làm là viết một biến thể của trình tạo dữ liệu trong đó các chuỗi đầu vào được hoàn
nguyên theo chiều thời gian (thay thế dòng cuối cùng bằng các mẫu năng suất [:, ::-1, :], mục tiêu).
Huấn luyện cùng một mạng một lớp GRU mà bạn đã sử dụng trong thử nghiệm đầu tiên trong phần
này, bạn sẽ nhận được kết quả như trong hình 6.24.

Hình 6.24 Mất khả năng xác thực và đào

tạo đối với nhiệm vụ dự báo nhiệt độ
Jena với GRU được đào tạo về trình tự
đảo ngược
GRU có thứ tự đảo ngược hoạt động kém hiệu quả hơn ngay cả so với đường cơ sở thông thường,
cho thấy rằng trong trường hợp này, quá trình xử lý theo trình tự thời gian rất quan trọng
đối với sự thành công của phương pháp tiếp cận của bạn. Điều này có ý nghĩa hoàn hảo: lớp
GRU bên dưới thường sẽ ghi nhớ quá khứ gần đây tốt hơn so với quá khứ xa xôi và đương
nhiên, các điểm dữ liệu thời tiết gần đây có tính dự đoán cao hơn các điểm dữ liệu cũ hơn
cho vấn đề (đó là điều tạo nên đường cơ sở thông thường Khá mạnh). Do đó, phiên bản theo
trình tự thời gian của lớp chắc chắn sẽ hoạt động tốt hơn phiên bản theo thứ tự đảo ngược.
Quan trọng là, điều này không đúng với nhiều vấn đề khác, bao gồm cả ngôn ngữ tự nhiên:
theo trực giác, tầm quan trọng của một từ trong việc hiểu một câu thường không phụ thuộc
vào vị trí của nó trong câu. Hãy thử thủ thuật tương tự trên ví dụ LSTM IMDB từ phần 6.2.
Liệt kê 6.42 Huấn luyện và đánh giá LSTM bằng cách sử dụng trình tự đảo ngược
từ keras.datasets nhập imdb từ

keras.preprocessing trình tự nhập từ máy ảnh nhập
các lớp từ keras.models nhập Sequential
Số từ được coi là Cắt các văn bản sau số
tính năng từ này (trong số các từ phổ
max_features = 10000 biến nhất trong max_features)
maxlen = 500
(x_train, y_train), (x_test, y_test) = imdb.load_data( num_words=max_features)
Tải
dữ liệu x_train = [x[::-1] cho x trong x_train] x_test đảo ngược
= [x[::-1] cho x trong x_test] trình tự
x_train = sequence.pad_sequences(x_train, maxlen=maxlen) x_test = miếng đệm
sequence.pad_sequences(x_test, maxlen=maxlen) trình tự
model.add(layers.Embedding(max_features, 128))
model.add(layers.LSTM(32)) model.add(layers.Dense(1,
activation='sigmoid'))
dimensions=['acc'])

history = model.fit(x_train, y_train, epochs=10,

batch_size=128,
Bạn nhận được hiệu suất gần giống với hiệu suất của LSTM theo thứ tự thời gian.
Đáng chú ý, trên tập dữ liệu văn bản như vậy, quá trình xử lý theo thứ tự đảo ngược hoạt
động giống như quá trình xử lý theo trình tự thời gian, xác nhận giả thuyết rằng, mặc dù trật
tự từ có ý nghĩa quan trọng trong việc hiểu ngôn ngữ, nhưng thứ tự bạn sử dụng không quan
trọng. Điều quan trọng là, một RNN được đào tạo dựa trên các trình tự đảo ngược sẽ học các
biểu diễn khác với RNN được đào tạo dựa trên các trình tự ban đầu, giống như bạn sẽ có các
mô hình tinh thần khác nếu thời gian trôi ngược trong thế giới thực—nếu bạn sống một cuộc đời
mà bạn chết vào ngày đầu tiên và được sinh ra vào ngày cuối cùng của bạn. Trong học máy, các
biểu diễn khác biệt nhưng hữu ích luôn đáng để khai thác và chúng càng khác biệt thì càng
tốt: chúng cung cấp một góc độ mới để xem xét dữ liệu của bạn, nắm bắt các khía cạnh của dữ
liệu mà các phương pháp khác đã bỏ qua, và do đó chúng có thể giúp tăng hiệu suất trong một
nhiệm vụ. Đây là trực giác đằng sau sự tập hợp, một khái niệm mà chúng ta sẽ khám phá trong chương 7.
RNN hai chiều khai thác ý tưởng này để cải thiện hiệu suất của các RNN theo thứ tự thời
gian . Nó xem xét trình tự đầu vào của nó theo cả hai cách (xem hình 6.25), thu được các
biểu diễn có tiềm năng phong phú hơn và nắm bắt các mẫu mà chỉ riêng phiên bản theo thứ tự
thời gian có thể đã bỏ qua.
Dữ liệu đầu vào
Hợp nhất
(thêm, nối)
RNN RNN
a, b, c, d, đ e, d, c, b, a
Trình tự thời đảo ngược Hình 6.25 Cách thức

a, b, c, d, đ
gian sự liên tiếp hoạt động của lớp RNN hai chiều
Để khởi tạo RNN hai chiều trong Keras, bạn sử dụng lớp Hai chiều , lớp này lấy đối số đầu
tiên là một thể hiện của lớp lặp lại làm đối số đầu tiên. Hai chiều tạo một phiên bản thứ
hai, riêng biệt của lớp lặp lại này và sử dụng một phiên bản để xử lý các chuỗi đầu vào theo
thứ tự thời gian và phiên bản còn lại để xử lý các chuỗi đầu vào theo thứ tự đảo ngược. Hãy
thử với nhiệm vụ phân tích tình cảm IMDB .
Liệt kê 6.43 Huấn luyện và đánh giá LSTM hai chiều
model.add(layers.Embedding(max_features, 32))
model.add(layers.Bilingual(layers.LSTM(32))) model.add(layers.Dense(1,
activation='sigmoid') )

model.compile(optimizer='rmsprop', loss='binary_crossentropy', dimensions=['acc']) history = model.fit(x_train,

y_train, epochs=10, batch_size=128, validation_split=0.2)
Nó hoạt động tốt hơn một chút so với LSTM thông thường mà bạn đã thử trong phần trước, đạt
được độ chính xác xác thực hơn 89%. Nó dường như cũng khớp nhanh hơn, điều này không có gì
đáng ngạc nhiên vì lớp hai chiều có số tham số gấp đôi so với LSTM logic chrono. Với một số
chính quy hóa, cách tiếp cận hai chiều có thể sẽ là một người thực hiện tốt nhiệm vụ này.
Bây giờ, hãy thử cách tiếp cận tương tự với nhiệm vụ dự đoán nhiệt độ.
Liệt kê 6.44 Huấn luyện GRU hai chiều

model = Sequential () model.add

(lớp. Hai chiều (
layer.GRU(32), input_shape=(Không, float_data.shape[-1])))

Điều này thực hiện cũng như lớp GRU thông thường . Thật dễ hiểu tại sao: tất cả khả năng dự
đoán phải đến từ nửa theo trình tự thời gian của mạng, bởi vì nửa ngược thời gian được biết
là hoạt động kém hiệu quả trong nhiệm vụ này (một lần nữa, vì quá khứ gần đây quan trọng
hơn nhiều so với quá khứ xa trong trường hợp này ).
6.3.9 Đi xa hơn nữa

Có nhiều thứ khác mà bạn có thể thử, để cải thiện hiệu suất cho vấn đề dự báo nhiệt độ:
Điều chỉnh số lượng đơn vị trong mỗi lớp lặp lại trong thiết lập xếp chồng. Các lựa
chọn hiện tại phần lớn là tùy ý và do đó có thể không tối ưu.
Điều chỉnh tốc độ học được sử dụng bởi trình tối ưu hóa
RMSprop . Hãy thử sử dụng các lớp LSTM thay vì các lớp
GRU . Hãy thử sử dụng một biến hồi quy có mật độ kết nối lớn hơn trên các lớp lặp
lại: nghĩa là một Lớp dày đặc lớn hơn hoặc thậm chí là một chồng các lớp Mật độ
cao . Cuối cùng, đừng quên chạy các mô hình hoạt động tốt nhất (về mặt xác thực MAE)
trên bộ thử nghiệm! Nếu không, bạn sẽ phát triển các kiến trúc quá phù hợp với bộ
xác thực.

Như mọi khi, học sâu là một nghệ thuật hơn là khoa học. Chúng tôi có thể cung cấp các hướng dẫn
đề xuất những gì có khả năng hiệu quả hoặc không hiệu quả đối với một vấn đề nhất định, nhưng
cuối cùng, mọi vấn đề đều là duy nhất; bạn sẽ phải đánh giá các chiến lược khác nhau theo kinh
nghiệm. Hiện tại không có lý thuyết nào cho bạn biết trước chính xác bạn nên làm gì để giải
quyết vấn đề một cách tối ưu. Bạn phải lặp đi lặp lại.
6.3.10 Kết thúc

Đây là những gì bạn nên rút ra từ phần này:
Như bạn đã học lần đầu tiên trong chương 4, khi tiếp cận một vấn đề mới, trước tiên bạn
nên thiết lập các đường cơ sở thông thường cho số liệu bạn chọn. Nếu bạn không có đường
cơ sở để đánh bại, bạn không thể biết mình có đang tiến bộ thực sự hay không. Hãy thử
các mô hình đơn giản trước những mô hình đắt tiền, để biện minh cho chi phí bổ sung.
Đôi khi một mô hình đơn giản sẽ trở thành lựa chọn tốt nhất của bạn.
Khi bạn có dữ liệu mà thứ tự thời gian là quan trọng, thì các mạng hồi quy rất phù hợp và
dễ dàng vượt trội so với các mô hình làm phẳng dữ liệu thời gian đầu tiên. Để sử dụng
dropout với các mạng lặp lại, bạn nên sử dụng mặt nạ dropout liên tục theo thời gian và mặt
nạ dropout lặp lại. Chúng được tích hợp vào các lớp lặp lại của Keras, vì vậy tất cả
những gì bạn phải làm là sử dụng các đối số dropout và reccurrent_dropout của các lớp lặp
lại. Các RNN xếp chồng cung cấp nhiều sức mạnh biểu diễn hơn so với một lớp RNN đơn
lẻ .
Chúng cũng đắt hơn nhiều và do đó không phải lúc nào cũng xứng đáng. Mặc dù chúng mang
lại lợi ích rõ ràng cho các vấn đề phức tạp (chẳng hạn như dịch máy), nhưng chúng có thể
không phải lúc nào cũng phù hợp với các vấn đề nhỏ hơn, đơn giản hơn. RNN hai chiều ,
xem xét trình tự theo cả hai cách, rất hữu ích đối với các vấn đề xử lý ngôn ngữ tự nhiên.
Nhưng chúng không hoạt động tốt trên dữ liệu trình tự trong đó quá khứ gần đây có nhiều
thông tin hơn so với phần đầu của
sự liên tiếp.
LƯU Ý Có hai khái niệm quan trọng mà chúng tôi sẽ không đề cập chi tiết ở đây: chú ý
tiền thuê lặp lại và mặt nạ trình tự. Cả hai đều có xu hướng đặc biệt phù hợp với xử
lý ngôn ngữ tự nhiên và chúng không đặc biệt áp dụng cho vấn đề dự báo nhiệt độ. Chúng
tôi sẽ để lại chúng cho nghiên cứu trong tương lai bên ngoài cuốn sách này.

Thị trường và học máy Một số độc

giả nhất định muốn sử dụng các kỹ thuật mà chúng tôi đã giới thiệu ở đây và thử
chúng với vấn đề dự báo giá chứng khoán trong tương lai trên thị trường chứng
khoán (hoặc tỷ giá hối đoái, v.v.). Thị trường có các đặc điểm thống kê rất khác
so với các hiện tượng tự nhiên như mô hình thời tiết. Cố gắng sử dụng máy học để
đánh bại thị trường, khi bạn chỉ có quyền truy cập vào dữ liệu có sẵn công khai,
là một nỗ lực khó khăn và bạn có khả năng lãng phí thời gian và tài nguyên của
mình mà không có gì để hiển thị.
Hãy luôn nhớ rằng khi nói đến thị trường, hiệu suất trong quá khứ không phải là yếu tố dự
báo tốt cho lợi nhuận trong tương lai—nhìn vào gương chiếu hậu là một cách lái xe tồi.
Mặt khác, học máy có thể áp dụng cho các bộ dữ liệu trong đó quá khứ là một yếu tố dự báo
tốt cho tương lai.

Xử lý trình tự với convnets 225
6.4 Xử lý trình tự với convnets

Trong chương 5, bạn đã tìm hiểu về mạng thần kinh tích chập (convnets) và cách chúng hoạt động đặc biệt tốt
đối với các vấn đề về thị giác máy tính, do khả năng hoạt động tích chập, trích xuất các tính năng từ các
bản vá lỗi đầu vào cục bộ và cho phép mô đun biểu diễn và hiệu quả dữ liệu. Các thuộc tính tương tự làm cho
mạng chuyển đổi vượt trội về thị giác máy tính cũng khiến chúng có liên quan cao đến xử lý trình tự.
Thời gian có thể được coi là một chiều không gian, giống như chiều cao hoặc chiều rộng của hình ảnh 2D .
Các kết nối 1D như vậy có thể cạnh tranh với RNN trong một số vấn đề xử lý trình tự nhất định, thường
với chi phí tính toán rẻ hơn đáng kể. Gần đây, mạng đối lưu 1D , thường được sử dụng với các nhân giãn nở,
đã được sử dụng rất thành công để tạo âm thanh và dịch máy. Ngoài những thành công cụ thể này, từ lâu người
ta đã biết rằng các kết nối 1D nhỏ có thể cung cấp giải pháp thay thế nhanh chóng cho RNN cho các tác vụ
đơn giản như phân loại văn bản và dự báo chuỗi thời gian.
6.4.1 Hiểu tích chập 1D cho dữ liệu chuỗi
Các lớp tích chập được giới thiệu trước đây là các tích chập 2D , trích xuất các bản vá 2D từ các bộ căng
hình ảnh và áp dụng một phép biến đổi giống hệt nhau cho mọi bản vá.
Theo cách tương tự, bạn có thể sử dụng các tích chập 1D , trích xuất các bản vá 1D cục bộ (các chuỗi con)
từ các chuỗi (xem hình 6.26).
Cửa sổ cỡ 5
tính
Đầu vào
năng đầu vào
Thời gian
bản vá trích
xuất
Chấm sản phẩm
với trọng lượng
Hình 6.26 Cách hoạt động của tích
tính chập 1D: mỗi dấu thời gian đầu ra

đầu ra
năng đầu ra được lấy từ một bản vá tạm thời
trong chuỗi đầu vào.
Các lớp tích chập 1D như vậy có thể nhận dạng các mẫu cục bộ theo trình tự. Bởi vì cùng một chuyển đổi đầu
vào được thực hiện trên mọi bản vá, nên sau đó, một mẫu đã học ở một vị trí nhất định trong câu có thể được
nhận dạng ở một vị trí khác, làm cho bản dịch mạng chuyển đổi 1D trở nên bất biến (đối với bản dịch tạm
thời). Chẳng hạn, một chuỗi xử lý mạng 1D của các ký tự sử dụng cửa sổ tích chập có kích thước 5 sẽ có thể
học các từ hoặc các đoạn từ có độ dài bằng 5 trở xuống và nó có thể nhận dạng

những từ này trong bất kỳ ngữ cảnh nào trong chuỗi đầu vào. Do đó, một convnet 1D cấp ký tự có
thể tìm hiểu về hình thái từ.
6.4.2 Tập hợp 1D cho dữ liệu trình tự
Bạn đã quen thuộc với các hoạt động tổng hợp 2D , chẳng hạn như tổng hợp trung bình 2D và tổng
hợp tối đa, được sử dụng trong các kết nối để lấy mẫu không gian cho các bộ căng hình ảnh. Hoạt
động tổng hợp 2D tương đương với 1D : trích xuất các bản vá 1D (các chuỗi con) từ một đầu vào và
xuất ra giá trị tối đa (tổng hợp tối đa) hoặc giá trị trung bình (tổng hợp trung bình).
Giống như với các kết nối 2D , điều này được sử dụng để giảm độ dài của đầu vào 1D (lấy mẫu con).
6.4.3 Triển khai hội tụ 1D
Trong Keras, bạn sử dụng convnet 1D thông qua lớp Conv1D , lớp này có giao diện tương tự như
Conv2D. Nó lấy các tenxơ 3D đầu vào có hình dạng (mẫu, thời gian, tính năng) và trả về các tenxơ
3D có hình dạng tương tự. Cửa sổ tích chập là cửa sổ 1D trên trục thời gian: trục 1 trong tenxơ
đầu vào.
Hãy xây dựng một hội nghị 1D hai lớp đơn giản và áp dụng nó vào nhiệm vụ phân loại tình cảm
IMDB mà bạn đã quen thuộc. Xin nhắc lại, đây là mã để lấy và xử lý trước dữ liệu.
Liệt kê 6.45 Chuẩn bị dữ liệu IMDB
từ keras.datasets nhập imdb từ trình tự nhập
keras.preprocessing
max_features = 10000 max_len =
500
print('Đang tải dữ liệu...') (x_train,
y_train), (x_test, y_test) = imdb.load_data(num_words=max_features) print(len(x_train), 'đào tạo trình tự')
print(len(x_test), ' trình tự kiểm tra')
print('Trình tự pad (mẫu x thời gian)') x_train =
sequence.pad_sequences(x_train, maxlen=max_len) x_test = sequence.pad_sequences(x_test,
maxlen=max_len) print('hình dạng x_train:', x_train.shape) print( 'hình dạng x_test:',
x_test.shape)
Các mạng kết nối 1D được cấu trúc giống như các đối tác 2D của chúng, mà bạn đã sử dụng trong
chương 5: chúng bao gồm một chồng các lớp Conv1D và MaxPooling1D , kết thúc bằng một lớp tổng
hợp toàn cầu hoặc một lớp Làm phẳng , biến các đầu ra 3D thành 2D đưa ra, cho phép bạn thêm một
hoặc nhiều lớp Mật độ cao vào mô hình để phân loại hoặc hồi quy.
Tuy nhiên, có một điểm khác biệt là bạn có đủ khả năng để sử dụng các cửa sổ tích chập lớn
hơn với các kết nối 1D . Với lớp tích chập 2D , cửa sổ tích chập 3 × 3 chứa 3 × 3 = 9 vectơ đặc
trưng; nhưng với lớp chập 1D , win dow tích chập có kích thước 3 chỉ chứa 3 vectơ đặc trưng. Do
đó, bạn có thể dễ dàng mua các cửa sổ tích chập 1D có kích thước 7 hoặc 9.

Đây là ví dụ hội nghị 1D cho bộ dữ liệu IMDB .
Liệt kê 6.46 Huấn luyện và đánh giá một hội nghị 1D đơn giản trên dữ liệu IMDB

model.add(layers.Embedding(max_features, 128, input_length=max_len)) model.add(layers.Conv1D(32, 7,
activation='relu')) model.add(layers.MaxPooling1D(5 )) model.add(layers.Conv1D(32, 7, activation='relu'))
model.add(layers.GlobalMaxPooling1D()) model.add(layers.Dense(1))
model.summary()
model.compile(optimizer=RMSprop(lr=1e-4),

validation_split=0.2 )
Hình 6.27 và 6.28 hiển thị kết quả đào tạo và xác nhận. Độ chính xác xác thực thấp hơn
một chút so với LSTM, nhưng thời gian chạy nhanh hơn trên cả CPU và GPU (mức tăng chính
xác về tốc độ sẽ khác nhau rất nhiều tùy thuộc vào cấu hình chính xác của bạn). Tại thời
điểm này, bạn có thể đào tạo lại mô hình này cho đúng số lượng kỷ nguyên (tám) và chạy nó
trên tập thử nghiệm. Đây là một minh chứng thuyết phục rằng mạng kết nối 1D có thể cung
cấp giải pháp thay thế nhanh, rẻ cho mạng định kỳ trong nhiệm vụ phân loại cảm xúc cấp độ từ.
Hình 6.27 Mất kiểm tra và đào

tạo trên IMDB với một
kết nối 1D đơn giản

Hình 6.28 Độ chính xác của

đào tạo và xác thực trên IMDB
với một convnet 1D đơn giản
6.4.4 Kết hợp CNN và RNN để xử lý chuỗi dài
Vì các mạng kết nối 1D xử lý các bản vá lỗi đầu vào một cách độc lập nên chúng không
nhạy cảm với thứ tự của dấu thời gian (ngoài tỷ lệ cục bộ, kích thước của các cửa sổ
tích chập), không giống như RNN. Tất nhiên, để nhận ra các mẫu dài hạn hơn, bạn có
thể xếp chồng nhiều lớp phức hợp và lớp tổng hợp, dẫn đến các lớp trên sẽ nhìn thấy
các đoạn dài của đầu vào ban đầu—nhưng đó vẫn là một cách khá yếu để tạo ra độ nhạy
của đơn hàng. Một cách để chứng minh điểm yếu này là thử kết nối 1D về vấn đề dự báo
nhiệt độ, trong đó độ nhạy của đơn hàng là chìa khóa để đưa ra dự đoán tốt. Ví dụ sau
sử dụng lại các biến sau được xác định trước đó: float_data, train_gen, val_gen và
val_steps.
Liệt kê 6.47 Huấn luyện và đánh giá một hội nghị 1D đơn giản trên dữ liệu Jena

model.add(layers.Conv1D(32, 5, activation='relu', input_shape=(None,
float_data.shape[-1]))) model.add(layers.MaxPooling1D(3))
model .add(layers.Conv1D(32, 5, activation='relu')) model.add(layers.MaxPooling1D(3))
model.add(layers.Conv1D(32, 5, activation='relu')) model. add(layers.GlobalMaxPooling1D())


Hình 6.29 cho thấy các MAE đào tạo và xác nhận.
Hình 6.29 Mất khả năng huấn

luyện và xác thực đối với tác
vụ dự báo nhiệt độ Jena với một

hội nghị 1D đơn giản
MAE xác thực duy trì trong 0,40 giây: bạn thậm chí không thể đánh bại đường cơ sở
thông thường bằng cách sử dụng convnet nhỏ. Một lần nữa, điều này là do convnet tìm
kiếm các mẫu ở bất kỳ vị trí nào trong chuỗi thời gian đầu vào và không biết vị trí
thời gian của một mẫu mà nó nhìn thấy (về đầu, về cuối, v.v.). Bởi vì các điểm dữ
liệu gần đây hơn nên được diễn giải khác với các điểm dữ liệu cũ hơn trong trường hợp
của vấn đề dự báo cụ thể này, nên convnet không thể tạo ra kết quả có ý nghĩa. Hạn
chế này của convnets không phải là vấn đề với dữ liệu IMDB , bởi vì các mẫu từ khóa
được liên kết với cảm xúc tích cực hoặc tiêu cực mang tính thông tin độc lập với vị
trí chúng được tìm thấy trong các câu đầu vào.
Một chiến lược để kết hợp tốc độ và độ nhẹ của kết nối với độ nhạy theo thứ tự của
RNN là sử dụng kết nối 1D làm bước tiền xử lý trước RNN (xem hình 6.30).
Điều này đặc biệt hữu ích khi bạn đang xử
lý các chuỗi dài đến mức chúng không thể
được xử lý trên thực tế bằng RNN, chẳng hạn
như các chuỗi có hàng nghìn bước. Mạng đối RNN
lưu sẽ biến chuỗi đầu vào dài thành chuỗi

ngắn hơn nhiều (được lấy mẫu xuống) của các
tính năng cấp cao hơn. Chuỗi các tính năng Ngắn hơn
tính năng CNN
sự liên tiếp
được trích xuất này sau đó trở thành đầu vào
cho phần RNN của mạng.
Kỹ thuật này không được thấy thường
CNN 1D
xuyên trong các tài liệu nghiên cứu và ứng
dụng thực tế, có thể vì nó không được biết
đến nhiều. Nó hiệu quả và nên phổ biến hơn.
Chuỗi dài
Hãy thử trên tập dữ liệu dự báo nhiệt độ.
Vì chiến lược này cho phép bạn xử lý các Hình 6.30 Kết hợp convnet 1D và RNN để xử lý
chuỗi dài hơn về sau, nên bạn có thể các chuỗi dài

xem dữ liệu từ lâu hơn (bằng cách tăng tham số xem lại của trình tạo dữ liệu) hoặc
xem chuỗi thời gian có độ phân giải cao (bằng cách giảm tham số bước của trình tạo).
Ở đây, hơi tùy tiện, bạn sẽ sử dụng một bước lớn bằng một nửa, dẫn đến chuỗi thời
gian dài gấp đôi, trong đó dữ liệu nhiệt độ được lấy mẫu với tốc độ 1 điểm trên 30
phút. Ví dụ sử dụng lại hàm tạo được xác định trước đó.
Liệt kê 6.48 Chuẩn bị trình tạo dữ liệu có độ phân giải cao hơn cho bộ dữ liệu Jena
bước = 3
nhìn lại = 720 Trước đây được đặt thành 6 (1 điểm mỗi giờ);
không thay đổi bây giờ là 3 (1 điểm mỗi 30 phút)
chậm trễ = 144
train_gen = máy phát điện (float_data,

lookback=lookback,
delay=delay, min_index=0,
max_index=200000,
shuffle=True, step=step)
val_gen = trình tạo (float_data,

lookback=nhìn lại, độ
trễ=độ trễ, min_index=200001,

max_index=300000, bước=bước)
test_gen = trình tạo (float_data,

lookback=lookback,
delay=delay,
min_index=300001,
max_index=None, step=step)
val_steps = (300000 -
200001 - lookback) // 128 test_steps = (len(float_data) - 300001 -
lookback) // 128
Đây là mô hình, bắt đầu với hai lớp Conv1D và tiếp theo là lớp GRU .
Hình 6.31 cho thấy kết quả.
Liệt kê 6.49 Mô hình kết hợp cơ sở tích chập 1D và lớp GRU

model.add(layers.Conv1D(32, 5, activation='relu', input_shape=(None,
float_data.shape[-1]))) model.add(layers.MaxPooling1D(3))
model .add(layers.Conv1D(32, 5, activation='relu')) model.add(layers.GRU(32, dropout=0.1,
recurrent_dropout=0.5)) model.add(layers.Dense(1))
model.summary()
model.compile(optimizer=RMSprop(), loss='mae')

lịch sử = model.fit_generator(train_gen,
step_per_epoch=500, epochs=20,
Hình 6.31 Mất khả năng huấn luyện và

xác thực đối với tác vụ dự báo nhiệt
độ Jena với hội nghị 1D theo sau là GRU
Đánh giá từ việc mất xác thực, thiết lập này không tốt bằng GRU được chuẩn hóa một mình,
nhưng nó nhanh hơn đáng kể. Nó xem xét lượng dữ liệu gấp đôi, trong trường hợp này có vẻ
không hữu ích lắm nhưng có thể quan trọng đối với các bộ dữ liệu khác.
6.4.5 Kết thúc

Đây là những gì bạn nên rút ra từ phần này:
Cũng giống như cách mà các hội đồng 2D hoạt động tốt để xử lý các mẫu trực quan trong
không gian 2D , các hội nghị 1D hoạt động tốt cho việc xử lý các mẫu thời gian. Chúng
cung cấp giải pháp thay thế nhanh hơn cho RNN trong một số vấn đề, đặc biệt là các
tác vụ xử lý ngôn ngữ tự nhiên.
Thông thường, các mạng 1D có cấu trúc giống như các mạng 2D tương đương của chúng
trong thế giới thị giác máy tính: chúng bao gồm các chồng lớp Conv1D và lớp Max
Pooling1D , kết thúc bằng hoạt động tổng hợp toàn cầu hoặc hoạt động làm phẳng. Vì
RNN cực kỳ tốn kém để xử lý các chuỗi rất dài, nhưng các kết nối 1D lại rẻ, nên có thể
sử dụng kết nối 1D như một bước xử lý trước RNN, rút ngắn chuỗi và trích xuất các
phản hồi đại diện hữu ích cho RNN để tiến trình.

Tóm tắt chương Trong
chương này, bạn đã học các kỹ thuật sau, được áp dụng rộng rãi cho bất kỳ
tập dữ liệu nào của dữ liệu trình tự, từ văn bản đến chuỗi thời gian:
– Cách mã hóa văn bản
– Word embeddings là gì và cách sử dụng chúng – Mạng

lặp lại là gì và cách sử dụng chúng – Cách xếp chồng
các lớp RNN và sử dụng RNN hai chiều để xây dựng các mô hình xử lý trình tự
đầy đủ mạnh mẽ hơn – Cách sử dụng kết nối 1D cho trình tự xử lý – Cách kết
hợp các kết nối 1D và RNN để xử lý các chuỗi dài Bạn có thể sử dụng RNN để
hồi quy chuỗi thời gian (“dự đoán tương lai”), phân loại chuỗi thời gian, phát
hiện bất thường trong chuỗi thời gian và ghi nhãn chuỗi (chẳng hạn như xác định
tên hoặc ngày trong câu) .
Tương tự, bạn có thể sử dụng các kết nối 1D để dịch máy (các mô hình tích chập
tuần tự sang chuỗi, như SliceNet a ), phân loại tài liệu và sửa lỗi chính tả.
Nếu thứ tự toàn cầu quan trọng trong dữ liệu trình tự của bạn, thì tốt hơn là
sử dụng mạng lặp lại để xử lý nó. Đây thường là trường hợp đối với chuỗi thời
gian, trong đó quá khứ gần đây có khả năng cung cấp nhiều thông tin hơn quá khứ
xa xôi.
Nếu việc đặt hàng toàn cầu về cơ bản không có ý nghĩa, thì các kết nối 1D ít
nhất cũng sẽ hoạt động tốt và rẻ hơn. Đây thường là trường hợp đối với dữ liệu
văn bản, trong đó từ khóa được tìm thấy ở đầu câu cũng có ý nghĩa như từ khóa
được tìm thấy ở cuối câu.
a Xem https://arxiv.org/abs/1706.03059.

Các phương pháp hay nhất về

học sâu nâng cao

API chức năng Keras
Sử dụng Keras callbacks
Làm việc với công cụ trực quan TensorBoard Các
phương pháp hay nhất quan trọng để phát triển các mô

hình tiên tiến nhất
Chương này khám phá một số công cụ mạnh mẽ sẽ đưa bạn đến gần hơn với khả năng phát
triển các mô hình tiên tiến nhất cho các vấn đề khó khăn. Sử dụng API chức năng Keras ,
bạn có thể xây dựng các mô hình giống như biểu đồ, chia sẻ một lớp trên các đầu vào khác
nhau và sử dụng các mô hình Keras giống như các hàm Python. Các lệnh gọi lại Keras và
công cụ trực quan hóa dựa trên trình duyệt TensorBoard cho phép bạn giám sát các mô hình
trong quá trình đào tạo. Chúng ta cũng sẽ thảo luận về một số phương pháp hay nhất khác
bao gồm chuẩn hóa hàng loạt, kết nối còn lại, tối ưu hóa siêu tham số và tập hợp mô hình.
233

234 CHƯƠNG 7 Các phương pháp hay nhất về học sâu nâng cao
7.1 Ngoài mô hình Tuần tự: API chức năng Keras
Cho đến nay, tất cả các mạng thần kinh được giới thiệu trong
đầu ra
cuốn sách này đều được triển khai bằng mô hình Tuần tự .
Mô hình tuần tự đưa ra giả định rằng mạng có chính xác một
đầu vào và chính xác một đầu ra, và nó bao gồm một chồng các Lớp
lớp tuyến tính (xem hình 7.1).

Đây là một giả định thường được xác minh; cấu hình phổ Lớp
biến đến mức chúng tôi có thể đề cập đến nhiều chủ đề và ứng
dụng thực tế trong các trang này cho đến nay chỉ bằng cách sử Lớp
dụng lớp mô hình Tuần tự . Nhưng tập hợp các giả định này quá
cứng nhắc trong một số trường hợp. Một số mạng yêu cầu một số tuần tự
đầu vào độc lập, một số khác yêu cầu nhiều đầu ra và một số Đầu vào
mạng có phân nhánh bên trong giữa các lớp khiến chúng trông
Hình 7.1 Một mô hình tuần tự :
giống như đồ thị của các lớp hơn là các chồng lớp tuyến tính. một chồng các lớp tuyến tính
Ví dụ, một số tác vụ yêu cầu đầu vào đa phương thức : chúng hợp nhất dữ liệu đến từ các
nguồn đầu vào khác nhau, xử lý từng loại dữ liệu bằng cách sử dụng các loại lớp thần kinh
khác nhau. Hãy tưởng tượng một mô hình học sâu đang cố gắng dự đoán giá thị trường có khả
năng xảy ra nhất của một bộ quần áo cũ, bằng cách sử dụng các thông tin đầu vào sau: siêu dữ
liệu do người dùng cung cấp (chẳng hạn như nhãn hiệu, độ tuổi của mặt hàng, v.v.), dữ liệu
do người dùng cung cấp mô tả văn bản, và một hình ảnh của mặt hàng. Nếu bạn chỉ có sẵn siêu
dữ liệu, bạn có thể mã hóa siêu dữ liệu một lần và sử dụng mạng được kết nối dày đặc để dự
đoán giá. Nếu bạn chỉ có sẵn mô tả văn bản, bạn có thể sử dụng RNN hoặc 1D convnet. Nếu bạn
chỉ có hình ảnh, bạn có thể sử dụng kết nối 2D . Nhưng làm thế nào bạn có thể sử dụng cả ba
cùng một lúc? Một cách tiếp cận ngây thơ sẽ là đào tạo ba mô hình riêng biệt và sau đó thực
hiện dự đoán tuổi trung bình có trọng số của chúng. Nhưng điều này có thể không tối ưu vì
thông tin được trích xuất bởi các mô hình có thể dư thừa. Một cách tốt hơn là cùng nhau tìm
hiểu một mô hình dữ liệu chính xác hơn bằng cách sử dụng một mô hình có thể xem đồng thời
tất cả các phương thức đầu vào có sẵn: một mô hình có ba nhánh đầu vào (xem hình 7.2).
Dự đoán giá
hợp
nhất mô-đun
Mô-đun RNN mô-đun dày đặc mô-đun kết nối
metadata mô tả văn bản Hình ảnh Hình 7.2 Mô hình nhiều đầu vào

Vượt ra ngoài mô hình Tuần tự: API chức năng Keras 235
Tương tự, một số tác vụ cần dự đoán nhiều thuộc tính đích của dữ liệu đầu vào. Với văn bản
của một cuốn tiểu thuyết hoặc truyện ngắn, bạn có thể muốn tự động phân loại nó theo thể
loại (chẳng hạn như lãng mạn hoặc ly kỳ) nhưng cũng dự đoán ngày nó được viết. Tất nhiên,
bạn có thể đào tạo hai mô hình riêng biệt: một cho thể loại và một cho ngày tháng. Nhưng
vì các thuộc tính này không độc lập về mặt thống kê nên bạn có thể xây dựng một mô hình
tốt hơn bằng cách học cách dự đoán đồng thời cả thể loại và ngày tháng. Khi đó, một mô
hình chung như vậy sẽ có hai đầu ra hoặc hai đầu (xem hình 7.3). Do mối tương quan giữa
thể loại và niên đại, việc biết niên đại của một cuốn tiểu thuyết sẽ giúp mô hình học được
những biểu hiện phong phú, chính xác về không gian của các thể loại tiểu thuyết và ngược lại.
thể loại Ngày
phân Ngày
loại thể loại hồi quy
module xử lý văn bản
văn bản tiểu thuyết
Hình 7.3 Mô hình nhiều đầu ra (hoặc nhiều đầu)
Ngoài ra, nhiều kiến trúc thần kinh được phát triển gần đây yêu cầu cấu trúc liên kết
công việc mạng phi tuyến tính: các mạng được cấu trúc dưới dạng đồ thị tuần hoàn có hướng.
Ví dụ, họ mạng Inception (được phát triển bởi Szegedy và cộng sự tại Google),1 dựa trên
các mô-đun Inception, trong đó đầu vào được xử lý bởi một số nhánh tích chập song song mà
đầu ra của chúng sau đó được hợp nhất lại thành một tensor duy nhất (xem hình 7.4) . Gần
đây cũng có xu hướng thêm các kết nối còn lại vào một mô hình, bắt đầu với họ mạng ResNet
(được phát triển bởi He và cộng sự tại Microsoft).2 Một kết nối còn lại bao gồm việc đưa
lại các biểu diễn trước đó vào luồng dữ liệu xuôi dòng bằng cách thêm chuyển một tenxơ đầu
ra trước đây sang một tenxơ đầu ra sau này (xem hình 7.5), điều này giúp ngăn ngừa mất
thông tin dọc theo luồng xử lý dữ liệu. Có nhiều ví dụ khác về các mạng giống như đồ thị.
1
Christian Szegedy và cộng sự, “Đi sâu hơn với kết cấu,” Hội nghị về thị giác máy tính và nhận dạng mẫu
(2014), https://arxiv.org/abs/1409.4842.
2
Kaiming He và cộng sự, “Deep Residual Learning for Image Recognition,” Conference on Computer Vision and
Pattern Recognition (2015), https://arxiv.org/abs/1512.03385.

đầu ra
nối
Conv2D
3 × 3, sải chân=2
Conv2D Conv2D Conv2D

3 × 3, sải chân=2 3 × 3 3 × 3
Conv2D Chuyển AvgPool2D Chuyển
1 × 1, sải chân=2 đổi2D 1 × 1 3 × 3, sải chân=2 đổi2D 1 × 1
Đầu vào
Hình 7.4 Một mô-đun khởi tạo: một sơ đồ con của các lớp với một số nhánh tích
chập song song
Lớp
Lớp Dư
sự liên quan
Lớp
Hình 7.5 Một kết nối còn lại: đưa lại

thông tin trước đó xuống dòng thông qua
Lớp
bổ sung bản đồ đặc trưng
Ba trường hợp sử dụng quan trọng này—mô hình nhiều đầu vào, mô hình nhiều đầu ra và mô
hình dạng biểu đồ—không thể thực hiện được khi chỉ sử dụng lớp mô hình Tuần tự trong
Keras. Nhưng có một cách khác tổng quát và linh hoạt hơn nhiều để sử dụng Keras: API
chức năng . Phần này giải thích chi tiết nó là gì, nó có thể làm gì và cách sử dụng nó.
7.1.1 Giới thiệu về API chức năng
Trong API chức năng, bạn trực tiếp thao tác với các tenxơ và bạn sử dụng các lớp làm
hàm nhận các tenxơ và trả về các tenxơ (do đó, có tên là API chức năng ):
từ máy ảnh nhập Đầu vào, các lớp
input_tensor = Đầu vào (hình dạng = (32,)) một tensor

dày đặc = layer.Dense(32, activation='relu') Một lớp là một chức năng.
output_tensor = dày đặc (input_tensor)

Một lớp có thể được gọi trên
một tensor và nó trả về một tensor.
Hãy bắt đầu với một ví dụ tối thiểu hiển thị song song một mô hình Tuần tự đơn giản và mô
hình tương đương trong API chức năng:
từ máy ảnh.models nhập Tuần tự, Mô hình từ máy ảnh nhập lớp từ máy
ảnh nhập Đầu vào

Mô hình tuần tự, mà bạn đã
biết về
seq_model = Sequential()
seq_model.add(layers.Dense(32, activation='relu', input_shape=(64,))) seq_model.add(layers.Dense(32,
activation='relu')) seq_model.add( layer.Dense(10, activation='softmax'))
input_tensor = Đầu vào(shape=(64,)) x = layer.Dense(32,
activation='relu')(input_tensor) x = layer.Dense(32, activation='relu')(x) output_tensor chức năng của nó
= layer.Dense (10, kích hoạt='softmax')(x) tương đương
mô hình = Mô hình (đầu vào_tensor, đầu ra_tensor)

Lớp Model biến một tenxơ đầu vào và một
model.summary() Hãy nhìn vào nó! tenxơ đầu ra thành một mô hình.
Đây là những gì cuộc gọi đến model.summary() hiển thị:
_________________________________________________________________
================================================================= ===============
đầu vào_1 (Lớp đầu vào) (Không, 64) 0
_________________________________________________________________
dày đặc_1 (Dày đặc) (Không có, 32) 2080
_________________________________________________________________
dày đặc_2 (Dày đặc) (Không có, 32) 1056
_________________________________________________________________
dày đặc_3 (Dày đặc) (Không, 10) 330

================================================================= ===============
Tổng số thông số: 3.466
_________________________________________________________________
Phần duy nhất có vẻ hơi kỳ diệu vào thời điểm này là khởi tạo một đối tượng Mô hình chỉ bằng
cách sử dụng một tensor đầu vào và một tensor đầu ra. Đằng sau hậu trường, Keras truy xuất
mọi lớp liên quan đến việc chuyển từ input_tensor sang output_tensor, kết hợp chúng lại với
nhau thành một cấu trúc dữ liệu giống như biểu đồ—một Mô hình. Tất nhiên, lý do nó hoạt động
là do output_tensor thu được bằng cách chuyển đổi input_tensor nhiều lần. Nếu bạn cố gắng xây
dựng một mô hình từ các đầu vào và đầu ra không liên quan với nhau, bạn sẽ nhận được thông báo Run
thời gianLỗi:
>>> không liên quan_input = Đầu vào (hình dạng = (32,)) >>>
bad_model = model = Model (unreled_input, output_tensor)

RuntimeError: Đồ thị bị ngắt kết nối: không thể lấy giá trị cho
tensor Tensor("input_1:0", shape=(?, 64), dtype=float32) tại
lớp "input_1".
Về bản chất, lỗi này cho bạn biết rằng Keras không thể tiếp cận đầu vào_1 từ tenxơ đầu ra
được cung cấp.
Khi nói đến việc biên dịch, đào tạo hoặc đánh giá một phiên bản Mô hình như vậy ,
API giống như của Sequential:
model.compile(optimizer='rmsprop', loss='categorical_crossentropy')
Biên dịch
mô hình
nhập numpy dưới dạng
Tạo dữ liệu Numpy giả để
np x_train = np.random.random((1000, 64)) huấn luyện
y_train = np.random.random((1000, 10))
model.fit(x_train, y_train, epochs=10, batch_size=128) Huấn luyện mô hình
điểm = model.evaluate(x_train, y_train) trong 10 kỷ nguyên

Đánh giá
mô hình
7.1.2 Mô hình nhiều đầu vào
API chức năng có thể được sử dụng để xây dựng các mô hình có nhiều đầu vào. Thông thường,
các mô hình như vậy tại một số điểm sẽ hợp nhất các nhánh đầu vào khác nhau của chúng
bằng cách sử dụng một lớp có thể kết hợp một số tenxơ: bằng cách thêm chúng, nối chúng,
v.v. Điều này thường được thực hiện thông qua thao tác hợp nhất Keras chẳng hạn như
keras.layers.add, keras.layers .concatenate, v.v. Hãy xem một ví dụ rất đơn giản về mô
hình đa đầu vào: mô hình trả lời câu hỏi.
Một mô hình trả lời câu hỏi điển hình có hai đầu vào: một câu hỏi bằng ngôn ngữ tự
nhiên và một đoạn văn bản (chẳng hạn như một bài báo) cung cấp thông tin được sử dụng để
trả lời câu hỏi. Sau đó, mô hình phải đưa ra câu trả lời: trong thiết lập đơn giản nhất
có thể, đây là câu trả lời một từ thu được thông qua softmax trên một số từ vựng được xác
định trước (xem hình 7.6).
Câu trả lời
Ngu độn
nối
LSTM LSTM
nhúng nhúng
văn bản tham khảo Câu hỏi Hình 7.6 Mô hình trả lời câu hỏi

Sau đây là một ví dụ về cách bạn có thể xây dựng một mô hình như vậy với API chức năng.
Bạn thiết lập hai nhánh độc lập, mã hóa đầu vào văn bản và đầu vào câu hỏi dưới dạng các vectơ biểu
diễn; sau đó, nối các vectơ này; và cuối cùng, thêm một trình phân loại softmax lên trên các biểu
diễn được nối.
Liệt kê 7.1 Triển khai API chức năng của mô hình trả lời câu hỏi hai đầu vào
từ máy ảnh.models nhập Mô hình từ máy ảnh

nhập lớp từ máy ảnh nhập Đầu vào
Đầu vào văn bản là một chuỗi
text_vocabulary_size = 10000 số nguyên có độ dài thay đổi.

Lưu ý rằng bạn có thể tùy ý đặt
question_vocabulary_size = 10000
tên cho các đầu vào.
answer_vocabulary_size = 500
text_input = Input(shape=(None,), dtype='int32', name='text')
embed_text = layer.Embedding(
64, text_vocabulary_size)(text_input)
Nhúng các đầu vào
vào một chuỗi các
encoded_text = layer.LSTM(32)(embedded_text)
vectơ có kích thước 64
question_input = Input(shape=(None,), dtype='int32', Mã hóa các vectơ trong một
name='câu hỏi') vectơ thông qua LSTM
Cùng một quy trình (với các phiên bản

nhúng_câu hỏi = lớp.Embedding( 32, question_vocabulary_size)
lớp khác nhau) cho câu hỏi
(câu hỏi_input) mã hóa_câu hỏi = lớp.LSTM(16)(embedded_question)
nối = layer.concatenate([encoded_text, encoded_question],

trục=-1)
Nối câu hỏi được mã hóa và
answer = layer.Dense(answer_vocabulary_size, activation='softmax') văn bản được mã hóa
(nối)
Thêm một softmax
model = Model([text_input, question_input], answer) phân loại trên đầu trang
Khi khởi tạo mô hình, bạn chỉ định hai
loss='categorical_crossentropy', dimensions=['acc'])
đầu vào và đầu ra.
Bây giờ, làm thế nào để bạn đào tạo mô hình hai đầu vào này? Có hai API khả thi: bạn có thể cung cấp
cho mô hình một danh sách các mảng Numpy làm đầu vào hoặc bạn có thể cung cấp cho mô hình một từ
điển ánh xạ các tên đầu vào tới các mảng Numpy. Đương nhiên, tùy chọn thứ hai chỉ khả dụng nếu bạn
đặt tên cho đầu vào của mình.
Liệt kê 7.2 Cung cấp dữ liệu cho mô hình nhiều đầu vào
nhập numpy dưới dạng np Tạo hình nộm

Dữ liệu nhiều dữ liệu
num_samples = 1000
max_length = 100
text = np.random.randint(1, text_vocabulary_size, size=(num_samples,

max_length))

Câu trả lời là một

câu hỏi = np.random.randint(1, question_vocabulary_size, mã hóa nóng,
size=(num_samples, max_length)) không phải số nguyên
câu trả lời = np.random.randint(0, 1,
size=(num_samples, answer_vocabulary_size))
model.fit([văn bản, câu hỏi], câu trả lời, epochs=10, batch_size=128)
model.fit({'văn bản': văn bản, 'câu hỏi': câu hỏi}, câu trả lời,
kỷ nguyên=10, batch_size=128)
Lắp bằng cách sử dụng danh sách đầu vào Lắp bằng từ điển đầu vào
(chỉ khi đầu vào được đặt tên)
7.1.3 Mô hình nhiều đầu ra

Theo cách tương tự, bạn có thể sử dụng API chức năng để xây dựng các mô hình có nhiều
đầu ra (hoặc nhiều đầu). Một ví dụ đơn giản là một mạng cố gắng dự đoán đồng thời các
thuộc tính khác nhau của dữ liệu, chẳng hạn như một mạng lấy đầu vào là một loạt các
bài đăng trên mạng xã hội từ một người ẩn danh và cố gắng dự đoán các thuộc tính của
người đó, chẳng hạn như tuổi, giới tính , và mức thu nhập (xem hình 7.7).
Liệt kê 7.3 Triển khai API chức năng của mô hình ba đầu ra
từ máy ảnh nhập các lớp từ máy ảnh
nhập Đầu vào từ máy ảnh.models nhập
Mô hình
vựng_size = 50000 num_ income_groups
= 10
posts_input = Input(shape=(None,), dtype='int32', name='posts') nhúng_posts = layer.Embedding(256,
vựng_size)(posts_input) x = layer.Conv1D(128, 5, activation='relu ')(embedded_posts) x = các lớp.MaxPooling1D(5)
(x) x = các lớp.Conv1D(256, 5, activation='relu')(x) x = các lớp.Conv1D(256, 5, activation='relu' )(x) x =
các lớp.MaxPooling1D(5)(x) x = các lớp.Conv1D(256, 5, activation='relu')(x) x = các lớp.Conv1D(256, 5,
activation='relu') (x) x = các lớp.GlobalMaxPooling1D()(x) x = các lớp.Dense(128, activation='relu')(x)
Lưu ý rằng các lớp

đầu ra được đặt tên.
age_prediction = Layers.Dense(1, name='age')(x) income_prediction =
Layers.Dense(num_ income_groups, activation='softmax', name=' Income')(x)

Gender_prediction = Layers.Dense(1,
activation= 'sigmoid', name='giới
tính')(x)
mô hình = Mô hình (posts_input,
[dự đoán_tuổi, dự đoán_thu nhập, dự đoán_giới tính])

Tuổi Thu nhập = earnings Giới tính
Ngu độn Ngu độn Ngu độn
kết nối 1D
Hình 7.7 Một mô hình truyền

Bài đăng trên mạng xã hội thông xã hội có ba đầu
Điều quan trọng là, việc đào tạo một mô hình như vậy đòi hỏi khả năng chỉ định các hàm mất
mát khác nhau cho các phần đầu khác nhau của mạng: ví dụ, dự đoán tuổi là một nhiệm vụ hồi
quy vô hướng, nhưng dự đoán giới tính là một nhiệm vụ phân loại nhị phân, yêu cầu một quy
trình đào tạo khác. Nhưng vì giảm độ dốc yêu cầu bạn giảm thiểu vô hướng, bạn phải kết hợp
các tổn thất này thành một giá trị duy nhất để đào tạo mô hình. Cách đơn giản nhất để kết hợp
các tổn thất khác nhau là tính tổng tất cả. Trong Keras, bạn có thể sử dụng danh sách hoặc
từ điển tổn thất trong trình biên dịch để chỉ định các đối tượng khác nhau cho các đầu ra
khác nhau; các giá trị tổn thất kết quả được tổng hợp thành một tổn thất toàn cầu, được giảm
thiểu trong quá trình đào tạo.
Liệt kê 7.4 Các tùy chọn biên dịch của mô hình nhiều đầu ra: nhiều tổn thất
loss=['mse', 'categorical_crossentropy', 'binary_crossentropy'])
Tương đương (chỉ có
loss={'tuổi': 'mse',
thể nếu bạn đặt tên
'thu nhập': 'categorical_crossentropy', 'giới tính':
cho các lớp đầu ra)
'binary_crossentropy'})
Lưu ý rằng các đóng góp tổn thất rất mất cân bằng sẽ khiến các biểu diễn mô hình được ưu tiên
tối ưu hóa cho nhiệm vụ có tổn thất riêng lẻ lớn nhất, gây thiệt hại cho các nhiệm vụ khác.
Để khắc phục điều này, bạn có thể gán các mức độ quan trọng khác nhau cho các giá trị tổn
thất trong phần đóng góp của chúng vào tổn thất cuối cùng. Điều này đặc biệt hữu ích nếu các
giá trị của tổn thất sử dụng các thang đo khác nhau. Chẳng hạn, tổn thất lỗi bình phương
trung bình (MSE) được sử dụng cho tác vụ hồi quy theo tuổi thường có giá trị khoảng 3–5,
trong khi tổn thất entropy chéo được sử dụng cho tác vụ phân loại giới tính có thể thấp tới
0,1. Trong tình huống như vậy, để cân bằng sự đóng góp của các tổn thất khác nhau, bạn có thể
gán trọng số 10 cho tổn thất crossentropy và trọng số 0,25 cho tổn thất MSE .
Liệt kê 7.5 Các tùy chọn biên dịch của mô hình đa đầu ra: giảm trọng số
loss=['mse', 'categorical_crossentropy', 'binary_crossentropy'], loss_weights=[0.25, 1., 10.])

loss={'tuổi': 'mse',
'thu nhập': 'categorical_crossentropy', 'giới tính':

Tương đương (chỉ có
'binary_crossentropy'}, loss_weights={'age': 0,25, thể nếu bạn đặt tên
cho các lớp đầu ra)
'thu nhập': 1.,
'giới tính': 10.})
Giống như trong trường hợp mô hình nhiều đầu vào, bạn có thể chuyển dữ liệu Numpy sang mô hình để
đào tạo thông qua danh sách các mảng hoặc thông qua từ điển các mảng.
Liệt kê 7.6 Cung cấp dữ liệu cho mô hình nhiều đầu ra
model.fit(bài đăng, [tuổi_mục tiêu, thu nhập_mục tiêu, giới tính_mục tiêu], epochs=10, batch_size=64)
model.fit(bài đăng, {'tuổi': age_targets, 'thu nhập':
income_targets, 'giới tính': giới

Tương đương (chỉ có thể nếu bạn
tính_mục tiêu}, đặt tên cho các lớp đầu ra)
kỷ nguyên=10, batch_size=64)
age_targets, income_targets
vàgiới_tích_giới tính được giả định
là các mảng Numpy.
7.1.4 Đồ thị tuần hoàn có hướng của các lớp
Với API chức năng, bạn không chỉ có thể xây dựng các mô hình có nhiều đầu vào và nhiều đầu ra mà
còn có thể triển khai các mạng có cấu trúc liên kết bên trong phức tạp.
Các mạng nơ-ron trong Keras được phép là các biểu đồ theo chu kỳ có hướng tùy ý của các lớp. Vòng
loại không theo chu kỳ rất quan trọng: những biểu đồ này không thể có chu kỳ. Không thể để tensor
x trở thành đầu vào của một trong các lớp tạo ra x. Các vòng xử lý duy nhất được phép (nghĩa là
các kết nối lặp lại) là các vòng lặp bên trong các lớp lặp lại.
Một số thành phần mạng thần kinh phổ biến được triển khai dưới dạng biểu đồ. Hai cái đáng chú
ý là các mô-đun Khởi động và các kết nối còn lại. Để hiểu rõ hơn về cách API chức năng có thể được
sử dụng để xây dựng biểu đồ của các lớp, chúng ta hãy xem cách bạn có thể triển khai cả hai trong
Keras.
MÔ-đun KHỞI ĐỘNG
Inception3 là một loại kiến trúc mạng phổ biến cho các mạng thần kinh tích chập; nó được Christian
Szegedy và các đồng nghiệp của ông tại Google phát triển vào năm 2013–2014, lấy cảm hứng từ kiến
trúc mạng trong mạng trước đó.4 Nó bao gồm một chồng các mô-đun giống như các mạng nhỏ độc lập,
được chia thành nhiều nhánh song song. Dạng cơ bản nhất của mô-đun Inception có ba đến bốn nhánh
bắt đầu bằng tích chập 1 × 1, tiếp theo là tích chập 3 × 3 và kết thúc bằng phép nối các đặc trưng
thu được. Thiết lập này giúp mạng học riêng
3
https://arxiv.org/abs/1409.4842.
4
Min Lin, Qiang Chen và Shuicheng Yan, “Mạng trong mạng,” Hội nghị quốc tế về biểu diễn học tập (2013), https://arxiv.org/abs/1312.4400.

các tính năng không gian và các tính năng theo kênh, hiệu quả hơn so với việc học
chúng cùng nhau. Cũng có thể có các phiên bản phức tạp hơn của mô-đun Inception, điển
hình liên quan đến các hoạt động tổng hợp, các kích thước tích chập không gian khác
nhau (ví dụ: 5 × 5 thay vì 3 × 3 trên một số nhánh) và các nhánh không có tích chập
không gian (chỉ 1 × 1 tích chập). Một ví dụ về mô-đun như vậy, được lấy từ Inception
V3, được hiển thị trong hình 7.8.
đầu ra
nối
Conv2D
3 × 3, sải chân=2
Conv2D Conv2D Conv2D

3 × 3, sải chân=2 3 × 3 3 × 3
Conv2D Chuyển AvgPool2D Chuyển

Hình 7.8 Mô-đun khởi
1 × 1, sải chân=2 đổi2D 1 × 1 3 × 3, sải chân=2 đổi2D 1 × 1
động
Đầu vào
Mục đích của phép tích chập 1 × 1 Bạn đã

biết rằng phép tích chập trích xuất các mảng không gian xung quanh mỗi ô trong một thang
đo đầu vào và áp dụng phép biến đổi tương tự cho từng mảng. Trường hợp cạnh là khi các
bản vá được trích xuất bao gồm một ô duy nhất. Khi đó, thao tác tích chập trở nên tương
đương với việc chạy từng vectơ khối ảnh qua một Lớp dày đặc : nó sẽ tính toán các tính
năng trộn thông tin với nhau từ các kênh của tensor đầu vào, nhưng nó sẽ không trộn thông
tin trong không gian (vì nó đang xem xét một khối ảnh tại một thời gian). Các phép tích
chập 1 × 1 như vậy (còn gọi là phép chập theo chiều điểm) được nêu trong các mô-đun
Inception, nơi chúng góp phần tạo ra tính năng học tập tính năng thông minh theo kênh và
học tập tính năng thông minh theo không gian—một điều hợp lý nên làm nếu bạn cho rằng mỗi
kênh có tính tự tương quan cao trên toàn bộ không gian, nhưng các kênh khác nhau có thể
không liên quan chặt chẽ với nhau.
Đây là cách bạn triển khai mô-đun có trong hình 7.8 bằng cách sử dụng API chức năng.
Ví dụ này giả định sự tồn tại của tensor đầu vào 4D x:

Mỗi nhánh có cùng giá trị sải chân (2), giá

trị này cần thiết để giữ cho tất cả các đầu ra Trong nhánh này, bước nhảy xảy ra
của nhánh có cùng kích thước để bạn có thể nối chúng. trong lớp tích chập không gian.
từ các lớp nhập máy ảnh
branch_a = layer.Conv2D(128, 1,
activation='relu', sải bước=2)(x) branch_b =
layer.Conv2D(128, 1, activation='relu')(x) branch_b = layer.Conv2D(128, 3, activation='relu',

sải bước= 2)(nhánh_b)
branch_c = layer.AveragePooling2D(3, sải chân=2)(x) branch_c = layer.Conv2D(128,

3, activation='relu')(branch_c)
branch_d = Layers.Conv2D(128, 1, activation='relu')(x) Branch_d = Layers.Conv2D(128,

3, activation='relu')(branch_d) branch_d = Layers.Conv2D(128, 3, activation= 'relu', sải chân=2)
(nhánh_d)
đầu ra = lớp.concatenate (
[nhánh_a, nhánh_b, nhánh_c, nhánh_d], trục=-1) Nối các đầu ra
nhánh để có được
Trong nhánh này, bước nhảy xảy ra đầu ra mô-đun
trong lớp tổng hợp trung bình.
Lưu ý rằng kiến trúc Inception V3 đầy đủ có sẵn trong Keras dưới dạng
keras.applications .inception_v3.InceptionV3, bao gồm các trọng số được đào tạo trước trên tập dữ liệu Imag
Một mô hình liên quan chặt chẽ khác có sẵn như là một phần của mô-đun ứng dụng Keras là
5
ngoại Xception, viết tắt của sự khởi đầu cực đoan, là một kiến trúc convnet lỏng lẻo
lệ. lấy cảm hứng từ Inception. Nó đưa ra ý tưởng tách việc học các tính năng theo kênh và
theo không gian đến mức cực đoan logic của nó và thay thế các mô-đun Inception bằng các
tích chập có thể tách rời theo chiều sâu bao gồm một tích chập theo chiều sâu (một tích
chập không gian trong đó mọi kênh đầu vào được xử lý riêng biệt) theo sau bằng phép tích
chập theo điểm (tích chập 1 × 1)—thực tế là một dạng cực đoan của mô-đun Inception, trong
đó các đặc điểm không gian và các đặc điểm theo kênh được tách biệt hoàn toàn. Xception có
số lượng tham số gần bằng với Inception V3, nhưng nó cho thấy hiệu suất thời gian chạy tốt
hơn và độ chính xác cao hơn trên ImageNet cũng như các bộ dữ liệu quy mô lớn khác, do sử
dụng các tham số mô hình hiệu quả hơn.
KẾT NỐI DƯ
Các kết nối còn lại là một thành phần mạng giống như biểu đồ phổ biến được tìm thấy trong
nhiều kiến trúc mạng sau năm 2015, bao gồm cả Xception. Chúng được giới thiệu bởi He et
al. từ Microsoft khi giành chiến thắng trong thử thách ILSVRC ImageNet vào cuối năm 2015.6
Họ giải quyết hai vấn đề phổ biến gây khó khăn cho bất kỳ mô hình học sâu quy mô lớn nào:
độ dốc biến mất và tắc nghẽn biểu diễn. Nói chung, việc thêm các kết nối còn lại vào bất
kỳ mô hình nào có nhiều hơn 10 lớp đều có thể mang lại lợi ích.
5
François Chollet, “Xception: Deep Learning with Depthwise Separable Convolutions,” Conference on
Computer Vision and Pattern Recognition (2017), https://arxiv.org/abs/1610.02357.
6
Anh ấy và cộng sự, “Deep Residual Learning for Image Recognition,” https://arxiv.org/abs/1512.03385.

Một kết nối còn lại bao gồm việc làm cho đầu ra của lớp trước có sẵn làm đầu vào
cho lớp sau, tạo một lối tắt hiệu quả trong mạng tuần tự. Thay vì được nối với lần
kích hoạt sau, đầu ra trước đó được tính tổng với lần kích hoạt sau, giả định rằng cả
hai lần kích hoạt đều có cùng kích thước. Nếu chúng có kích thước khác nhau, bạn có
thể sử dụng phép biến đổi tuyến tính để định hình lại kích hoạt trước đó thành hình
dạng mục tiêu (ví dụ: Lớp dày đặc không có kích hoạt hoặc đối với bản đồ tính năng
tích chập, tích chập 1 × 1 không có kích hoạt).
Đây là cách triển khai kết nối còn lại trong Keras khi kích thước bản đồ tính năng
giống nhau, sử dụng các kết nối còn lại nhận dạng. Ví dụ này giả định sự tồn tại của
tensor đầu vào 4D x:
từ các lớp nhập máy ảnh Áp dụng phép biến đổi cho x
x = ...
y = layer.Conv2D(128, 3, activation='relu', padding='same')(x) y = layer.Conv2D(128,
3, activation='relu', padding='same')(y) y = layer.Conv2D(128, 3, activation='relu',
padding='same')(y)
y = layer.add([y, x])
Thêm x ban đầu trở lại các
tính năng đầu ra
Và phần sau đây triển khai kết nối thặng dư khi kích thước bản đồ đặc trưng khác nhau,
sử dụng kết nối thặng dư tuyến tính (một lần nữa, giả sử có sự tồn tại của tenxơ đầu
vào 4D x):
Sử dụng phép tích chập 1 × 1
từ các lớp nhập máy ảnh để lấy mẫu tuyến tính của tensor
x ban đầu về cùng hình dạng với y
x = ...
y = layer.Conv2D(128, 3, activation='relu', padding='same')(x) y = layer.Conv2D(128,
3, activation='relu', padding='same')(y) y = các lớp.MaxPooling2D(2, sải chân=2)(y)
thặng dư = lớp.Conv2D(128, 1, sải chân=2, đệm='same')(x)
y = layer.add([y, dư]) Thêm tensor còn lại vào
các tính năng đầu ra
Nút cổ chai biểu diễn trong học sâu Trong mô hình

Tuần tự , mỗi lớp biểu diễn kế tiếp được xây dựng trên lớp trước đó, có nghĩa là
nó chỉ có quyền truy cập vào thông tin có trong phần kích hoạt của lớp trước đó.
Nếu một lớp quá nhỏ (ví dụ, nó có các tính năng quá ít chiều), thì mô hình sẽ bị
hạn chế bởi lượng thông tin có thể được nhồi nhét vào các kích hoạt của lớp này.

(còn tiếp)
Bạn có thể hiểu khái niệm này bằng phép loại suy xử lý tín hiệu: nếu bạn có một quy trình
xử lý âm thanh bao gồm một loạt hoạt động, mỗi hoạt động sẽ nhận đầu vào là đầu ra của
hoạt động trước đó, thì nếu một hoạt động cắt tín hiệu của bạn xuống mức thấp -dải tần số
(ví dụ: 0–15 kHz), các hoạt động xuôi dòng sẽ không bao giờ có thể phục hồi các tần số bị
giảm. Bất kỳ mất mát thông tin là vĩnh viễn.
Các kết nối còn lại, bằng cách đưa lại thông tin trước đó xuống dòng, giải quyết một phần
vấn đề này cho các mô hình học sâu.
Độ dốc biến mất trong học sâu Tính năng lan

truyền ngược, thuật toán chính được sử dụng để huấn luyện mạng nơ-ron sâu, hoạt động bằng
cách truyền tín hiệu phản hồi từ suy hao đầu ra xuống các lớp trước đó. Nếu tín hiệu phản
hồi này phải được truyền qua một chồng các lớp sâu, thì tín hiệu có thể trở nên yếu ớt
hoặc thậm chí bị mất hoàn toàn, khiến mạng không thể huấn luyện được. Vấn đề này được gọi
là độ dốc biến mất.
Sự cố này xảy ra với cả mạng sâu và mạng lặp lại trong các chuỗi rất dài—trong cả hai
trường hợp, tín hiệu phản hồi phải được truyền qua một chuỗi dài các hoạt động. Bạn đã
quen thuộc với giải pháp mà lớp LSTM sử dụng để giải quyết vấn đề này trong các mạng lặp
lại: nó giới thiệu một đường truyền truyền thông tin song song với đường xử lý chính. Các
kết nối còn lại hoạt động theo cách tương tự trong các mạng cấp dữ liệu sâu, nhưng chúng
thậm chí còn đơn giản hơn: chúng giới thiệu một đường dẫn mang thông tin tuyến tính thuần
túy song song với ngăn xếp lớp chính, do đó giúp truyền gradient qua các ngăn xếp lớp sâu
tùy ý.
7.1.5 Chia sẻ trọng lượng lớp
Một tính năng quan trọng hơn của API chức năng là khả năng sử dụng lại một phiên bản lớp nhiều lần. Khi bạn gọi
một thể hiện của lớp hai lần, thay vì khởi tạo một lớp mới cho mỗi lần gọi, bạn sử dụng lại các trọng số giống
nhau với mỗi lần gọi. Điều này cho phép bạn
xây dựng các mô hình có các nhánh được chia sẻ — một số nhánh chia sẻ cùng một
kiến thức và thực hiện các thao tác tương tự. Nghĩa là, chúng chia sẻ các biểu diễn giống nhau và học các biểu
diễn này đồng thời cho các tập hợp đầu vào khác nhau.
Ví dụ, hãy xem xét một mô hình cố gắng đánh giá sự giống nhau về ngữ nghĩa giữa hai câu. Mô hình có hai đầu
vào (hai câu để so sánh) và đầu ra có điểm từ 0 đến 1, trong đó 0 có nghĩa là các câu không liên quan và 1 có
nghĩa là
các câu giống hệt nhau hoặc cải cách của nhau. Một mô hình như vậy
có thể hữu ích trong nhiều ứng dụng, bao gồm loại bỏ các truy vấn ngôn ngữ tự nhiên trùng lặp trong một hệ
thống hộp thoại.
Trong thiết lập này, hai câu đầu vào có thể hoán đổi cho nhau, bởi vì sự giống nhau về ngữ nghĩa là mối
quan hệ đối xứng: sự giống nhau của A với B giống hệt với sự giống nhau của B với A. Vì lý do này, sẽ không có
ý nghĩa gì khi học hai câu độc lập. mô hình cho

xử lý từng câu đầu vào. Thay vào đó, bạn muốn xử lý cả hai với một lớp LSTM . Các biểu diễn của lớp
LSTM này (trọng số của nó) được học dựa trên cả hai đầu vào đồng thời. Đây là những gì chúng tôi gọi
là mô hình LSTM Xiêm hoặc LSTM được chia sẻ .
Đây là cách triển khai mô hình như vậy bằng cách sử dụng chia sẻ lớp (tái sử dụng lớp) trong
API chức năng Keras :
Khởi tạo một

Lớp LSTM, một lần
nhập Đầu vào từ máy ảnh.models nhập
Mô hình
Xây dựng nhánh trái của mô
hình: đầu vào là các chuỗi vectơ
lstm = layer.LSTM(32)
có độ dài thay đổi có kích thước 128.
left_input = Input(shape=(None, 128)) left_output =
lstm(left_input) Xây dựng nhánh bên phải của mô hình: khi bạn
gọi một thể hiện của lớp hiện có, bạn sử
right_input = Input(shape=(None, 128)) right_output =
dụng lại các trọng số của nó.
lstm(right_input)
đã hợp nhất = các lớp.concatenate([left_output, right_output], axis=-1) dự đoán = các lớp.Dense(1,

activation='sigmoid')(đã hợp nhất)
mô hình = Mô hình ([left_input, right_input], dự đoán) model.fit ([left_data,

right_data], target)
Xây dựng bộ phân loại trên đầu trang Khởi tạo và đào tạo mô hình: khi bạn đào tạo
một mô hình như vậy, các trọng số của lớp LSTM
được cập nhật dựa trên cả hai đầu vào.
Đương nhiên, một thể hiện lớp có thể được sử dụng nhiều lần—nó có thể được gọi tùy ý nhiều lần, mỗi
lần sử dụng lại cùng một tập trọng số.
7.1.6 Mô hình dưới dạng lớp
Điều quan trọng là trong API chức năng, các mô hình có thể được sử dụng giống như cách bạn sử dụng
các lớp—một cách hiệu quả, bạn có thể coi mô hình là một “lớp lớn hơn”. Điều này đúng với cả lớp
Sequential và Model . Điều này có nghĩa là bạn có thể gọi một mô hình trên một tensor đầu vào và lấy
một tensor đầu ra:
y = mô hình (x)
Nếu mô hình có nhiều tensors đầu vào và nhiều tensors đầu ra, nó sẽ được gọi với một danh sách các
tensors:
y1, y2 = mô hình([x1, x2])
Khi bạn gọi một phiên bản mô hình, bạn đang sử dụng lại các trọng số của mô hình—chính xác như những
gì xảy ra khi bạn gọi một phiên bản lớp. Việc gọi một phiên bản, cho dù đó là phiên bản lớp hay phiên
bản mô hình, sẽ luôn sử dụng lại các biểu diễn đã học hiện có của phiên bản—điều này mang tính trực
quan.
Một ví dụ thực tế đơn giản về những gì bạn có thể tạo bằng cách sử dụng lại phiên bản mô hình là
mô hình thị giác sử dụng máy ảnh kép làm đầu vào: hai máy ảnh song song, cách nhau vài cm (một inch).
Một mô hình như vậy có thể cảm nhận được độ sâu, điều này có thể hữu ích trong nhiều ứng dụng. Bạn
không cần hai mô hình độc lập để trích xuất hình ảnh

các tính năng từ máy ảnh bên trái và máy ảnh bên phải trước khi hợp nhất hai nguồn cấp dữ liệu.
Quá trình xử lý cấp thấp như vậy có thể được chia sẻ trên hai đầu vào: nghĩa là, được thực
hiện thông qua các lớp sử dụng cùng trọng số và do đó chia sẻ cùng biểu diễn. Đây là cách bạn
triển khai mô hình tầm nhìn Xiêm (cơ sở tích chập được chia sẻ) trong Keras:

Mô hình xử lý ảnh cơ sở là
nhập ứng dụng từ máy ảnh nhập Đầu vào
mạng Xception (chỉ cơ sở tích
chập).
xception_base = application.Xception(trọng số=Không, bao gồm_top=Sai)
left_input = Đầu vào (hình dạng = (250, 250, 3)) right_input

Đầu vào là hình ảnh 250 ×
= Đầu vào (hình dạng = (250, 250, 3)) 250 RGB.
left_features = xception_base(left_input) right_input = Gọi cùng một mô hình

xception_base(right_input) tầm nhìn hai lần
merge_features = layer.concatenate(
[left_features, right_input], axis=-1)
Các tính năng được hợp nhất chứa thông
tin từ nguồn cấp dữ liệu trực quan bên phải

và nguồn cấp dữ liệu trực quan bên trái.
7.1.7 Kết thúc

Điều này kết thúc phần giới thiệu của chúng tôi về API chức năng Keras —một công cụ cần thiết cho
xây dựng kiến trúc mạng lưới thần kinh sâu tiên tiến. Bây giờ bạn biết những điều sau đây:
Để thoát khỏi API tuần tự bất cứ khi nào bạn cần bất kỳ thứ gì khác ngoài một chồng các
lớp liên tục Cách xây dựng các mô hình Keras với một số đầu vào, một số đầu ra và
cấu trúc liên kết mạng nội bộ phức tạp, sử dụng API chức năng Keras Cách sử dụng lại
các trọng số của một lớp hoặc mô hình trên các nhánh xử lý khác nhau, bằng cách gọi
cùng một lớp hoặc phiên bản mô hình nhiều lần

Kiểm tra và giám sát các mô hình học sâu bằng cách sử dụng các cuộc gọi lại Keras và TensorBoard 249
7.2 Kiểm tra và giám sát các mô hình học sâu bằng cách sử dụng các
cuộc gọi lại Keras và TensorBoard
Trong phần này, chúng tôi sẽ xem xét các cách để có quyền truy cập và kiểm soát tốt hơn đối với những gì
diễn ra bên trong mô hình của bạn trong quá trình đào tạo. Khởi chạy một đợt huấn luyện trên một tập dữ
liệu lớn trong hàng chục kỷ nguyên bằng cách sử dụng model.fit() hoặc model.fit_generator() có thể hơi
giống với việc khởi chạy một chiếc máy bay giấy: sau xung lực ban đầu, bạn không có bất kỳ quyền kiểm
soát nào đối với quỹ đạo của nó hoặc điểm hạ cánh của nó. Nếu bạn muốn tránh những hậu quả xấu (và do đó
lãng phí máy bay giấy), sẽ thông minh hơn nếu không sử dụng máy bay giấy mà là sử dụng máy bay không
người lái có thể cảm nhận môi trường của nó, gửi dữ liệu lại cho người điều khiển và tự động đưa ra quyết
định điều khiển dựa trên hiện tại của nó. tiểu bang. Các kỹ thuật chúng tôi trình bày ở đây sẽ biến lệnh
gọi model.fit() từ một chiếc máy bay giấy thành một máy bay không người lái thông minh, tự động có thể tự
xem xét nội tâm và thực hiện hành động một cách linh hoạt.
7.2.1 Sử dụng lệnh gọi lại để thực hiện trên một mô hình trong quá trình đào tạo
Khi bạn đào tạo một người mẫu, có nhiều điều bạn không thể đoán trước được ngay từ đầu.
Đặc biệt, bạn không thể biết cần bao nhiêu kỷ nguyên để đạt được mức mất giá trị tối ưu. Các ví dụ cho
đến nay đã áp dụng chiến lược đào tạo cho đủ số kỷ nguyên mà bạn bắt đầu trang bị quá mức, sử dụng lần
chạy đầu tiên để tìm ra số lượng kỷ nguyên phù hợp để đào tạo, sau đó cuối cùng khởi chạy một đợt đào tạo
mới từ đầu bằng cách sử dụng con số tối ưu này. Tất nhiên, cách tiếp cận này là lãng phí.
Một cách tốt hơn nhiều để giải quyết vấn đề này là ngừng đào tạo khi bạn đo lường rằng sự mất giá
trị không còn được cải thiện. Điều này có thể đạt được bằng cách sử dụng gọi lại Keras. Gọi lại là một
đối tượng (một thể hiện của lớp triển khai các phương thức cụ thể) được chuyển đến mô hình trong lệnh gọi
để khớp và được gọi bởi mô hình tại các điểm khác nhau trong quá trình đào tạo. Nó có quyền truy cập vào
tất cả dữ liệu có sẵn về trạng thái của mô hình và hiệu suất của nó, đồng thời có thể thực hiện hành
động: ngắt đào tạo, lưu mô hình, tải một bộ trọng lượng khác hoặc thay đổi trạng thái của mô hình.
Dưới đây là một số ví dụ về cách bạn có thể sử dụng lệnh gọi lại:
Điểm kiểm tra mô hình—Lưu các trọng số hiện tại của mô hình tại các điểm khác nhau
Trong quá trình huấn luyện.
Dừng sớm —Làm gián đoạn quá trình đào tạo khi tình trạng mất xác thực không còn được cải thiện (và
tất nhiên, lưu mô hình tốt nhất thu được trong quá trình đào tạo). Tự động điều chỉnh giá trị
của các thông số nhất định trong quá trình đào tạo—Chẳng hạn như
tốc độ học tập của trình tối ưu hóa.
Ghi nhật ký các chỉ số đào tạo và xác thực trong quá trình đào tạo hoặc trực quan hóa các biểu
diễn mà mô hình đã học được khi chúng được cập nhật— Thanh tiến trình Keras mà bạn quen thuộc là
một lệnh gọi lại!
Mô -đun keras.callbacks bao gồm một số lệnh gọi lại tích hợp sẵn (đây không phải là danh sách đầy đủ):
keras.callbacks.ModelCheckpoint
keras.callbacks.EarlyStopping

keras.callbacks.LearningRateScheduler
keras.callbacks.ReduceLROnPlateau
keras.callbacks.CSVLogger
Hãy xem xét một vài trong số chúng để cung cấp cho bạn ý tưởng về cách sử dụng chúng:
ModelCheckpoint, EarlyStopping và ReduceLROnPlateau.
MODELCHECKPOINT VÀ DỪNG GỌI SỚM
Bạn có thể sử dụng lệnh gọi lại EarlyStopping để làm gián đoạn đào tạo sau khi chỉ số
mục tiêu được theo dõi đã ngừng cải thiện trong một số kỷ nguyên cố định. Chẳng hạn,
lệnh gọi lại này cho phép bạn ngắt đào tạo ngay khi bạn bắt đầu trang bị quá mức, do
đó tránh phải đào tạo lại mô hình của bạn với số lượng kỷ nguyên nhỏ hơn. Cuộc gọi lại
này thường được sử dụng kết hợp với ModelCheckpoint, cho phép bạn liên tục lưu mô hình
trong quá trình đào tạo (và, tùy chọn, chỉ lưu mô hình tốt nhất hiện tại cho đến nay:
phiên bản của mô hình đạt được hiệu suất tốt nhất vào cuối một kỷ nguyên) :
Các cuộc gọi lại được chuyển đến mô hình thông qua Ngừng đào tạo khi ngừng cải
đối số cuộc gọi lại phù hợp, đối số này nhận danh sách tiến
các cuộc gọi lại. Bạn có thể vượt qua bất kỳ số lần gọi lại nào.
Theo dõi độ chính xác
nhập khẩu máy ảnh xác thực của mô hình
callbacks_list = Làm gián đoạn đào tạo khi độ
[ keras.callbacks.EarlyStopping ( màn hình = chính xác đã ngừng cải thiện
'acc', kiên nhẫn = 1, trong hơn một kỷ nguyên (nghĩa là

hai kỷ nguyên)
), Lưu trọng số hiện tại sau mỗi kỷ nguyên

Đường dẫn đến tệp mô hình đích
keras.callbacks.ModelCheckpoint( filepath='my_model.h5', monitor='val_loss',

Hai đối số này có nghĩa là bạn sẽ save_best_only=True,
không ghi đè lên tệp mô
) hình trừ khi val_loss được cải thiện, điều này cho phép bạn giữ
] mô hình tốt nhất được thấy trong quá trình đào tạo.
loss='binary_crossentropy', Bạn theo dõi độ chính xác, vì vậy nó phải
dimensions=['acc']) là một phần của số liệu của mô hình.
model.fit(x, y,
Lưu ý rằng vì cuộc gọi lại sẽ giám sát
epochs=10,
việc mất xác thực và độ chính xác của
batch_size=32,
xác thực, nên bạn cần chuyển dữ liệu xác
callbacks=callbacks_list,
thực cho cuộc gọi cho phù hợp.
GỌI LẠI REDUCELRONPLATEAU
Bạn có thể sử dụng lệnh gọi lại này để giảm tốc độ học tập khi tình trạng mất xác thực
đã ngừng cải thiện. Giảm hoặc tăng tỷ lệ học tập trong trường hợp mất ổn định là một
chiến lược hiệu quả để thoát khỏi cực tiểu cục bộ trong quá trình đào tạo. Ví dụ sau
đây sử dụng lệnh gọi lại ReduceLROnPlateau :

callbacks_list = Theo dõi mất xác nhận
[ keras.callbacks.ReduceLROnPlateau( monitor='val_loss' của mô hình
factor=0.1, Patent=10,
Chia tỷ lệ học tập cho 10 khi được kích hoạt
Cuộc gọi lại được kích hoạt sau khi mất xác
)
thực đã ngừng cải thiện trong 10 kỷ nguyên.
]
model.fit(x, y,
Bởi vì cuộc gọi lại sẽ
epochs=10,
theo dõi việc mất xác thực, bạn
batch_size=32,
cần chuyển dữ liệu xác thực cho
callbacks=callbacks_list,
cuộc gọi để phù hợp.
VIẾT GỌI LẠI CỦA RIÊNG BẠN
Nếu bạn cần thực hiện một hành động cụ thể trong quá trình đào tạo không thuộc phạm vi của một
trong các lệnh gọi lại tích hợp, bạn có thể viết lệnh gọi lại của riêng mình. Các cuộc gọi lại
được triển khai bằng cách phân lớp phụ lớp keras.callbacks.Callback. Sau đó, bạn có thể triển
khai bất kỳ số lượng phương thức được đặt tên minh bạch nào sau đây, được gọi tại các điểm khác
nhau trong quá trình đào tạo:
on_epoch_begin Được gọi vào đầu mỗi kỷ nguyên

on_epoch_end Được gọi vào cuối mỗi kỷ nguyên
on_batch_begin Được gọi ngay trước khi xử lý từng đợt

on_batch_end Được gọi ngay sau khi xử lý từng đợt
on_train_begin Được gọi khi bắt đầu đào tạo

on_train_end Được gọi khi kết thúc đào tạo
Tất cả các phương thức này đều được gọi với một đối số nhật ký , là một từ điển chứa thông tin về
đợt, kỷ nguyên hoặc lần chạy đào tạo trước đó: số liệu đào tạo và xác thực, v.v. Ngoài ra, cuộc
gọi lại có quyền truy cập vào các thuộc tính sau:
self.model—Phiên bản mô hình mà callback đang được gọi từ đó self.validation_data
— Giá trị của những gì được chuyển để phù hợp với dạng dữ liệu xác thực
Đây là một ví dụ đơn giản về gọi lại tùy chỉnh lưu vào đĩa (dưới dạng mảng Numpy) kích hoạt của
mọi lớp của mô hình ở cuối mỗi kỷ nguyên, được tính trên mẫu đầu tiên của bộ xác thực:
nhập máy ảnh nhập

numpy dưới dạng np
Được gọi bởi mô hình gốc
lớp ActivationLogger(keras.callbacks.Callback): trước khi đào tạo, để thông

báo cho cuộc gọi lại về mô
def set_model(bản thân, mô hình): hình nào sẽ gọi nó
self.model = người mẫu
layer_outputs = [layer.output cho layer trong model.layers] self.activations_model =

keras.models.Model(model.input,
layer_outputs)
Phiên bản mô
def on_epoch_end(self, epoch, logs=None): nếu self.validation_data
hình trả về kích
là Không: tăng RuntimeError('Yêu cầu xác thực_data.')
hoạt của mọi
lớp

validation_sample = self.validation_data[0][0:1] activations =

self.activations_model.predict(validation_sample) f = open('activations_at_epoch_' +
str(epoch) + '.npz', 'w') np.savez(f , kích hoạt) f.close()
Lấy mẫu đầu vào đầu tiên của

Lưu mảng vào đĩa
dữ liệu xác thực
Đây là tất cả những gì bạn cần biết về lệnh gọi lại—phần còn lại là các chi tiết kỹ thuật mà bạn có
thể dễ dàng tra cứu. Giờ đây, bạn đã được trang bị để thực hiện bất kỳ loại ghi nhật ký hoặc can
thiệp lập trình sẵn nào trên mô hình Keras trong quá trình đào tạo.
7.2.2 Giới thiệu về TensorBoard: khung trực
quan hóa TensorFlow
Để thực hiện nghiên cứu tốt hoặc phát triển các mô hình tốt, bạn cần có phản hồi thường xuyên,
phong phú về những gì đang diễn ra bên trong các mô hình của bạn trong quá trình thử nghiệm. Đó là
mục đích của việc chạy thử nghiệm: để có được thông tin về hiệu suất của một mô hình—càng nhiều
thông tin càng tốt. Tiến bộ là một quá trình lặp đi lặp lại hoặc vòng lặp: bạn bắt đầu với một ý
tưởng và thể hiện nó dưới dạng thử nghiệm, cố gắng xác thực hoặc làm mất hiệu lực ý tưởng của bạn.
Bạn chạy thử nghiệm này và xử lý thông tin mà nó tạo ra. Điều này truyền cảm hứng cho ý tưởng tiếp
theo của bạn. Bạn càng có thể lặp lại nhiều lần vòng lặp này, ý tưởng của bạn càng trở nên tinh tế
và mạnh mẽ hơn. Máy ảnh giúp bạn đi từ ý tưởng đến thử nghiệm trong thời gian ít nhất có thể và GPU
nhanh có thể giúp bạn đi từ thử nghiệm đến kết quả nhanh nhất có thể. Nhưng còn việc xử lý kết quả
thí nghiệm thì sao? Đó là nơi Tensor Board xuất hiện.
Ý tưởng
Khung trực Khung học sâu:

quan hóa:
TenorBoard máy ảnh
Kết quả Thí nghiệm
cơ sở hạ tầng
Hình 7.9 Vòng lặp tiến trình
Phần này giới thiệu TensorBoard, một công cụ trực quan hóa dựa trên trình duyệt đi kèm với
TensorFlow. Lưu ý rằng nó chỉ khả dụng cho các mẫu máy ảnh Keras khi bạn đang sử dụng Máy ảnh với
phụ trợ TensorFlow.
Mục đích chính của TensorBoard là giúp bạn theo dõi trực quan mọi thứ diễn ra bên trong mô hình
của bạn trong quá trình đào tạo. Nếu bạn đang theo dõi nhiều thông tin hơn là chỉ tổn thất cuối
cùng của mô hình, bạn có thể phát triển một tầm nhìn rõ ràng hơn về những gì mô hình làm và không
làm, và bạn có thể tiến bộ nhanh hơn. TensorBoard cung cấp cho bạn quyền truy cập vào một số tính
năng thú vị, tất cả đều có trong trình duyệt của bạn:

Theo dõi trực quan các số liệu trong quá

trình đào tạo Trực quan hóa kiến trúc mô hình
của bạn Trực quan hóa biểu đồ kích hoạt và độ dốc
Khám phá các nhúng trong 3D
Hãy chứng minh các tính năng này trên một ví dụ đơn giản. Bạn sẽ đào tạo một hội nghị 1D
về nhiệm vụ phân tích tình cảm IMDB .
Mô hình này tương tự như mô hình bạn đã thấy trong phần trước của chương 6. Bạn sẽ chỉ
xem xét 2.000 từ hàng đầu trong từ vựng IMDB , để làm cho việc nhúng từ trực quan trở nên
dễ xử lý hơn.
Liệt kê 7.7 Mô hình phân loại văn bản để sử dụng với TensorBoard
nhập máy ảnh từ

máy ảnh nhập lớp từ máy ảnh.datasets Số từ được coi là tính
năng
nhập imdb từ máy ảnh.trình tự nhập tiền xử lý
Cắt các văn bản sau số từ này
max_features = 2000 max_len (trong số các từ phổ biến nhất

= 500 trong số max_features)
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features) x_train = sequence.pad_sequences(x_train,

maxlen=max_len) x_test = sequence.pad_sequences(x_test, maxlen=max_len)
model = keras.models.Sequential()
model.add(layers.Embedding(max_features, 128,
input_length=max_len,
name='embed'))
model.add(layers.Conv1D(32, 7, activation='relu'))
model.add(layers.MaxPooling1D(5)) model.add(layers.Conv1D(32 , 7,
activation='relu')) model.add(layers.GlobalMaxPooling1D())
model.add(layers.Dense(1)) model.summary() model.compile(optimizer='rmsprop',
loss='binary_crossentropy ', số liệu = ['acc'])
Trước khi bắt đầu sử dụng TensorBoard, bạn cần tạo một thư mục nơi bạn sẽ lưu trữ các tệp
nhật ký mà nó tạo ra.
Liệt kê 7.8 Tạo một thư mục cho các tệp nhật ký TensorBoard
$ mkdir my_log_dir
Hãy bắt đầu đào tạo với phiên bản gọi lại TensorBoard . Cuộc gọi lại này sẽ ghi các sự
kiện nhật ký vào đĩa tại vị trí đã chỉ định.

Liệt kê 7.9 Huấn luyện mô hình với lệnh gọi lại TensorBoard
gọi lại = [
Các tệp nhật ký sẽ được
keras.callbacks.TensorBoard(
ghi tại vị trí này.
log_dir='my_log_dir',
histogram_freq=1,
Ghi lại biểu đồ kích hoạt cứ sau 1 kỷ nguyên
embeddings_freq=1,
)
Ghi lại dữ liệu nhúng
mỗi 1 kỷ nguyên
] history = model.fit(x_train, y_train, epochs=20,
batch_size=128,
validation_split=0.2,
callbacks=callbacks)
Tại thời điểm này, bạn có thể khởi chạy máy chủ TensorBoard từ dòng lệnh, hướng dẫn nó đọc
nhật ký mà cuộc gọi lại hiện đang viết. Tiện ích tensorboard phải được cài đặt tự động trên
máy của bạn ngay khi bạn cài đặt TensorFlow (ví dụ: qua pip):
$ tensorboard --logdir=my_log_dir
Sau đó, bạn có thể duyệt đến http://localhost:6006 và xem phần đào tạo mô hình của mình (xem
hình 7.10). Ngoài các biểu đồ trực tiếp về số liệu đào tạo và xác thực, bạn có quyền truy cập
vào tab Biểu đồ, nơi bạn có thể tìm thấy các hình ảnh trực quan đẹp mắt về biểu đồ của các
giá trị kích hoạt do các lớp của bạn thực hiện (xem hình 7.11).
Hình 7.10 TensorBoard: giám sát số liệu

Hình 7.11 TensorBoard: biểu đồ kích hoạt
Tab Nhúng cung cấp cho bạn một cách để kiểm tra các vị trí nhúng và mối quan hệ
không gian của 10.000 từ trong từ vựng đầu vào, như lớp Nhúng ban đầu đã học
được . Vì không gian nhúng là 128 chiều, TensorBoard tự động giảm nó thành 2D
hoặc 3D bằng cách sử dụng thuật toán giảm kích thước do bạn chọn: phân tích thành
phần chính (PCA) hoặc nhúng hàng xóm ngẫu nhiên phân bổ t (t-SNE). Trong hình
7.12, trong đám mây điểm, bạn có thể thấy rõ hai cụm: từ có nghĩa tích cực và từ
có nghĩa tiêu cực. Quá trình trực quan hóa làm cho rõ ràng ngay lập tức rằng các
nhúng được đào tạo cùng với một mục tiêu cụ thể dẫn đến các mô hình hoàn toàn cụ
thể cho nhiệm vụ cơ bản—đó là lý do tại sao việc sử dụng các nhúng từ chung được
đào tạo trước hiếm khi là một ý tưởng hay.

Hình 7.12 TensorBoard: trực quan hóa nhúng từ 3D tương tác
Tab Đồ thị hiển thị hình ảnh trực quan tương tác của đồ thị của các hoạt động TensorFlow cấp thấp bên dưới
mô hình Keras của bạn (xem hình 7.13). Như bạn có thể thấy, có rất nhiều điều đang diễn ra hơn bạn mong đợi.
Mô hình bạn vừa xây dựng có thể trông đơn giản khi được xác định trong Keras—một chồng nhỏ các lớp cơ bản—
nhưng bên trong, bạn cần xây dựng một cấu trúc biểu đồ khá phức tạp để làm cho nó hoạt động. Rất nhiều trong
số đó có liên quan đến quá trình giảm độ dốc. Sự khác biệt phức tạp này giữa những gì bạn nhìn thấy và những
gì bạn đang thao tác là động lực chính để sử dụng Keras làm cách xây dựng mô hình của bạn, thay vì làm việc
với TensorFlow thô để xác định mọi thứ từ đầu.
Keras làm cho quy trình làm việc của bạn đơn giản hơn đáng kể.

Hình 7.13 TensorBoard: Trực quan hóa biểu đồ TensorFlow
Lưu ý rằng Keras cũng cung cấp một cách khác, rõ ràng hơn để vẽ các mô hình dưới dạng biểu đồ của các
lớp thay vì biểu đồ của các hoạt động của TensorFlow: tiện ích keras.utils.plot_model.
Để sử dụng nó, bạn phải cài đặt các thư viện pydot và pydot-ng của Python cũng như thư viện graphviz .
Hãy xem nhanh:
từ keras.utils nhập plot_model
plot_model(model, to_file='model.png')
Điều này tạo ra hình ảnh PNG được hiển thị trong hình 7.14.

Hình 7.14 Biểu đồ mô hình dưới dạng biểu đồ các

lớp, được tạo bằng plot_model
Bạn cũng có tùy chọn hiển thị thông tin hình dạng trong biểu đồ lớp. Ví dụ này trực
quan hóa cấu trúc liên kết mô hình bằng cách sử dụng tùy chọn plot_model và
show_shapes (xem hình 7.15):
từ keras.utils nhập plot_model
plot_model(model, show_shapes=True, to_file='model.png')

Hình 7.15 Một biểu đồ mô hình với thông tin hình dạng
7.2.3 Kết thúc

Keras callbacks cung cấp một cách đơn giản để giám sát các mô hình trong quá trình đào tạo và tự
động thực hiện hành động dựa trên trạng thái của mô hình. Khi bạn đang sử dụng TensorFlow,
TensorBoard là một cách tuyệt vời để trực quan hóa hoạt động của mô hình trong trình duyệt của bạn.
Bạn có thể sử dụng nó trong các mô hình Keras thông qua lệnh gọi lại TensorBoard .

7.3 Khai thác tối đa các mô hình của bạn

Thử các kiến trúc hoạt động một cách mù quáng là đủ tốt nếu bạn chỉ cần thứ gì đó hoạt động ổn.
Trong phần này, chúng tôi sẽ đi xa hơn từ “hoạt động ổn” đến “hoạt động tuyệt vời và giành chiến
thắng trong các cuộc thi máy học” bằng cách cung cấp cho bạn hướng dẫn nhanh về một tập hợp các
kỹ thuật cần biết để xây dựng công nghệ học sâu tiên tiến nhất. người mẫu.
7.3.1 Các mẫu kiến trúc nâng cao
Chúng tôi đã trình bày chi tiết về một mẫu thiết kế quan trọng trong phần trước: các kết nối còn
lại. Có hai mẫu thiết kế nữa mà bạn nên biết: chuẩn hóa và tích chập có thể phân tách theo chiều
sâu. Các mẫu này đặc biệt phù hợp khi bạn đang xây dựng deep convnets hiệu suất cao, nhưng chúng
cũng thường được tìm thấy trong nhiều loại kiến trúc khác.
BÌNH THƯỜNG HÓA HÀNG LỚP
Chuẩn hóa là một danh mục rộng lớn các phương pháp tìm cách làm cho các mẫu khác nhau được mô
hình học máy nhìn thấy giống nhau hơn, giúp mô hình học và khái quát hóa tốt dữ liệu mới. Hình
thức chuẩn hóa dữ liệu phổ biến nhất là hình thức mà bạn đã thấy vài lần trong cuốn sách này: căn
giữa dữ liệu về 0 bằng cách lấy dữ liệu trừ đi giá trị trung bình và cho dữ liệu một độ lệch
chuẩn đơn vị bằng cách chia dữ liệu cho độ lệch chuẩn của nó. Trên thực tế, điều này đưa ra giả
định rằng dữ liệu tuân theo phân phối chuẩn (hoặc Gaussian) thấp và đảm bảo phân phối này được
căn giữa và chia tỷ lệ thành phương sai đơn vị:
normalized_data = (dữ liệu - np.mean(dữ liệu, trục=...)/np.std(dữ liệu, trục=...)
Các ví dụ trước đã chuẩn hóa dữ liệu trước khi đưa nó vào các mô hình. Nhưng việc chuẩn hóa dữ
liệu phải là mối quan tâm sau mỗi lần chuyển đổi do mạng vận hành: ngay cả khi dữ liệu đi vào
mạng Dense hoặc Conv2D có phương sai đơn vị và trung bình bằng 0, thì không có lý do gì để mong
đợi một tiên nghiệm rằng đây sẽ là trường hợp của dữ liệu sắp ra.
Chuẩn hóa hàng loạt là một loại lớp (Chuẩn hóa hàng loạt trong Keras) được giới thiệu vào năm
2015 bởi Ioffe và Szegedy;7 nó có thể chuẩn hóa dữ liệu một cách thích ứng ngay cả khi giá trị
trung bình và phương sai thay đổi theo thời gian trong quá trình đào tạo. Nó hoạt động bằng cách
duy trì nội bộ một đường trung bình động theo cấp số nhân của giá trị trung bình theo lô và phương
sai của dữ liệu nhìn thấy trong quá trình đào tạo. Tác dụng chính của chuẩn hóa hàng loạt là nó
giúp truyền gradient—giống như các kết nối còn lại—và do đó cho phép các mạng sâu hơn. Một số
mạng rất sâu chỉ có thể được đào tạo nếu chúng bao gồm nhiều lớp Chuẩn hóa hàng loạt . Chẳng hạn,
BatchNormalization được sử dụng tự do trong nhiều kiến trúc convnet nâng cao đi kèm với Keras,
chẳng hạn như ResNet50, Inception V3 và Xception.
7
Sergey Ioffe và Christian Szegedy, “Chuẩn hóa hàng loạt: Tăng tốc đào tạo mạng sâu bằng cách giảm sự
thay đổi đồng biến nội bộ,” Kỷ yếu của Hội nghị quốc tế lần thứ 32 về học máy (2015), https://arxiv.org/
abs/1502.03167.

Khai thác tối đa các mô hình của bạn 261
Lớp BatchNormalization thường được sử dụng sau lớp tích chập hoặc lớp kết nối dày đặc:
conv_model.add(layers.Conv2D(32, 3, activation='relu')) Sau một lớp Conv

conv_model.add(layers.BatchNormalization())
density_model.add(layers.Dense(32, Sau một lớp dày đặc

activation='relu'))density_model.add(layers.BatchNormalization())
Lớp BatchNormalization lấy một đối số trục , chỉ định trục tính năng sẽ được chuẩn hóa. Đối
số này mặc định là -1, trục cuối cùng trong tensor đầu vào. Đây là giá trị chính xác khi sử
dụng Lớp dày đặc , lớp Conv1D , lớp RNN và lớp Conv2D với data_format được đặt thành
"channels_last". Nhưng trong trường hợp sử dụng thích hợp của các lớp Conv2D với data_format
được đặt thành "channels_first", trục tính năng là trục 1; đối số trục trong
BatchNormalization tương ứng phải được đặt thành 1.
Tái chuẩn hóa hàng loạt
Một cải tiến gần đây so với chuẩn hóa hàng loạt thông thường là tái chuẩn hóa hàng loạt, được
giới thiệu bởi Ioffe vào năm 2017.a Nó mang lại lợi ích rõ ràng so với chuẩn hóa hàng loạt mà
không phải trả chi phí rõ ràng. Tại thời điểm viết bài này, còn quá sớm để biết liệu nó có thay
thế quá trình chuẩn hóa hàng loạt hay không—nhưng tôi nghĩ có khả năng là như vậy. Thậm chí gần
dữ liệu được chuẩn hóa sau khi đi qua đây
các hơn,
mạng Klambauer
thần kinh et
tự al.
chuẩn
đã hóa,
giới thông
thiệu qua
b quản
bất lý
kỳ để
lớpgiữ
Dense
cho
nào bằng cách sử dụng một chức năng kích hoạt cụ thể (selu) và một bộ khởi tạo cụ thể
(lecun_normal). Sơ đồ này, mặc dù rất thú vị, nhưng hiện tại chỉ giới hạn ở các mạng được kết nối
dày đặc và tính hữu dụng của nó vẫn chưa được nhân rộng.
Sergey Ioffe, “Tái chuẩn hóa hàng loạt: Hướng tới giảm sự phụ thuộc vào minibatch trong các mô
một
hình chuẩn hóa hàng loạt” (2017), https://arxiv.org/abs/1702.03275.

b
Günter Klambauer và cộng sự, “Mạng thần kinh tự chuẩn hóa,” Hội nghị về Hệ thống xử lý thông tin
thần kinh (2017), https://arxiv.org/abs/1706.02515.
CHUYỂN ĐỔI DEPTHWISE CÓ THỂ TÁCH BIỆT
Điều gì sẽ xảy ra nếu tôi nói với bạn rằng có một lớp mà bạn có thể sử dụng làm lớp thay
thế tùy chọn cho Conv2D. Lớp này sẽ làm cho mô hình của bạn nhẹ hơn (ít tham số trọng lượng
có thể đào tạo hơn) và nhanh hơn (ít thao tác dấu phẩy động hơn) và khiến nó thực hiện một
vài điểm phần trăm tốt hơn về nhiệm vụ của nó? Đó chính xác là những gì lớp tích chập có
thể phân tách theo chiều sâu thực hiện (SeparableConv2D). Lớp này thực hiện tích chập không
gian trên mỗi kênh của đầu vào của nó, một cách độc lập, trước khi trộn các kênh đầu ra
thông qua tích chập theo điểm (tích chập 1 × 1), như thể hiện trong hình 7.16. Điều này
tương đương với việc tách biệt việc học các đặc điểm không gian và học các đặc điểm theo
kênh, điều này rất có ý nghĩa nếu bạn giả định rằng các vị trí không gian trong đầu vào có
mối tương quan cao, nhưng các kênh khác nhau lại khá độc lập. Nó yêu cầu ít tham số hơn đáng
kể và liên quan đến ít tính toán hơn, do đó dẫn đến các mô hình nhỏ hơn, nhanh hơn. Và bởi
vì đó là một cách hiệu quả hơn về mặt biểu diễn để thực hiện tích chập, nên nó có xu hướng
học các biểu diễn tốt hơn bằng cách sử dụng ít dữ liệu hơn, dẫn đến các mô hình hoạt động tốt hơn.

Chuyển đổi 1 ×
1 (chuyển đổi theo điểm)
nối
Tích chập theo chiều sâu:

chuyển đổi không gian độc
lập trên mỗi kênh
Chuyển đổi 3 × 3 chuyển đổi 3 × 3 chuyển đổi 3 × 3 chuyển đổi 3 × 3 chuyển đổi
Hình 7.16 Tích chập có thể tách rời

Tách kênh
theo chiều sâu: tích chập theo chiều sâu
theo sau là tích chập theo điểm
Những lợi thế này trở nên đặc biệt quan trọng khi bạn đào tạo các mô hình nhỏ từ đầu
trên dữ liệu hạn chế. Chẳng hạn, đây là cách bạn có thể xây dựng một convnet nhẹ, có
thể phân tách theo chiều sâu cho một tác vụ phân loại hình ảnh (phân loại phân loại
softmax) trên một tập dữ liệu nhỏ:
từ máy ảnh.models nhập Tuần tự, Mô hình từ các lớp nhập máy ảnh
chiều cao = 64
chiều rộng = 64
kênh = 3
số_lớp = 10
model.add(layers.SeparableConv2D(32, 3,
activation='relu',
input_shape=(chiều cao, chiều rộng, kênh,)))
model.add(layers.SeparableConv2D(64, 3, activation='relu')) model.add(layers.MaxPooling2D(2))
model.add(layers.SeparableConv2D(64, 3, activation='relu')) model.add(layers.SeparableConv2D(128,
3, activation='relu')) model.add(layers.MaxPooling2D(2))
3, activation='relu')) model.add(layers.GlobalAveragePooling2D())
model.add(layers.Dense(32, activation='relu')) model.add(layers.Dense(num_classes,
activation='softmax'))
Khi nói đến các mô hình quy mô lớn hơn, các kết cấu có thể phân tách theo chiều sâu là
cơ sở của kiến trúc Xception, một mạng kết nối hiệu suất cao đi kèm với Keras. Bạn có
thể đọc thêm về cơ sở lý thuyết để phân tách theo chiều sâu

convolutions và Xception trong bài viết của tôi “Xception: Deep Learning với Depthwise Separate
Convolutions.”8
7.3.2 Tối ưu hóa siêu tham số

Khi xây dựng một mô hình học sâu, bạn phải đưa ra nhiều quyết định có vẻ tùy tiện: Bạn nên xếp bao
nhiêu lớp? Có bao nhiêu đơn vị hoặc bộ lọc nên đi trong mỗi lớp? Bạn nên sử dụng relu làm kích hoạt
hay một chức năng khác? Bạn có nên sử dụng BatchNormalization sau một lớp nhất định không? Bạn nên
sử dụng bao nhiêu dropout? Và như thế. Các tham số cấp kiến trúc này được gọi là siêu tham số để
phân biệt chúng với các tham số của một mô hình, được đào tạo thông qua lan truyền ngược.
Trên thực tế, các kỹ sư và nhà nghiên cứu máy học có kinh nghiệm xây dựng trực giác theo thời
gian về những gì hiệu quả và những gì không khi nói đến những lựa chọn này—
họ phát triển các kỹ năng điều chỉnh siêu tham số. Nhưng không có quy tắc chính thức. Nếu bạn muốn
đạt đến giới hạn tối đa của những gì có thể đạt được trong một nhiệm vụ nhất định, bạn không thể
bằng lòng với những lựa chọn tùy tiện của một con người dễ mắc sai lầm. Những quyết định ban đầu
của bạn hầu như luôn dưới mức tối ưu, ngay cả khi bạn có trực giác tốt. Bạn có thể tinh chỉnh các
lựa chọn của mình bằng cách điều chỉnh chúng bằng tay và đào tạo lại mô hình nhiều lần—đó là điều
mà các nhà nghiên cứu và kỹ sư máy học dành phần lớn thời gian của họ để làm. Nhưng công việc của
bạn với tư cách là một con người không phải là loay hoay với các siêu tham số cả ngày—điều đó tốt
hơn là để máy móc làm.
Do đó, bạn cần khám phá không gian của các quyết định khả thi một cách tự động, có hệ thống,
theo một cách có nguyên tắc. Bạn cần tìm kiếm không gian kiến trúc và tìm những cái hoạt động tốt
nhất theo kinh nghiệm. Đó là nội dung của lĩnh vực tối ưu hóa siêu tham số tự động: đó là toàn bộ
lĩnh vực nghiên cứu và là một lĩnh vực quan trọng.
Quá trình tối ưu hóa siêu tham số thường như sau: 1 Chọn một bộ siêu tham số
(tự động).
2 Xây dựng mô hình tương ứng.
3 Khớp nó với dữ liệu đào tạo của bạn và đo lường hiệu suất cuối cùng trên hợp lệ
dữ liệu.
4 Chọn bộ siêu tham số tiếp theo để thử (tự động).
5 Lặp lại.
6 Cuối cùng, hãy đo hiệu suất trên dữ liệu thử nghiệm của bạn.
Chìa khóa của quy trình này là thuật toán sử dụng lịch sử hiệu suất xác thực này, được cung cấp
nhiều bộ siêu tham số khác nhau, để chọn tập hợp siêu tham số tiếp theo để đánh giá. Có thể sử dụng
nhiều kỹ thuật khác nhau: tối ưu hóa Bayesian, thuật toán di truyền, tìm kiếm ngẫu nhiên đơn giản,
v.v.
Đào tạo trọng số của một mô hình tương đối dễ dàng: bạn tính toán hàm mất mát trên một lô dữ
liệu nhỏ và sau đó sử dụng thuật toán Lan truyền ngược để di chuyển trọng số
Xem lưu ý 5 ở trên.

số 8

đúng hướng. Mặt khác, việc cập nhật các siêu tham số là vô cùng khó khăn. Hãy xem xét những
điều sau đây:
Việc tính toán tín hiệu phản hồi (bộ siêu tham số này có dẫn đến một mô hình có hiệu
suất cao trong nhiệm vụ này không?) có thể cực kỳ tốn kém: nó yêu cầu tạo và huấn
luyện một mô hình mới từ đầu trên tập dữ liệu của bạn.
Không gian siêu tham số thường được tạo thành từ các quyết định rời rạc và do đó
không liên tục hoặc khả vi. Do đó, bạn thường không thể thực hiện giảm độ dốc trong
không gian siêu tham số. Thay vào đó, bạn phải dựa vào các kỹ thuật tối ưu hóa không
có độ dốc, vốn kém hiệu quả hơn nhiều so với giảm độ dốc.
Bởi vì những thách thức này rất khó khăn và lĩnh vực này vẫn còn non trẻ, chúng tôi hiện chỉ
có quyền truy cập vào các công cụ rất hạn chế để tối ưu hóa các mô hình. Thông thường, hóa
ra tìm kiếm ngẫu nhiên (chọn siêu tham số để đánh giá ngẫu nhiên, lặp đi lặp lại) là giải
pháp tốt nhất, mặc dù là giải pháp ngây thơ nhất. Nhưng một công cụ tôi thấy đáng tin cậy
hơn tìm kiếm ngẫu nhiên là Hyperopt (https://github.com/hyperopt/hyperopt), một thư viện
Python để tối ưu hóa siêu tham số sử dụng nội bộ các cây ước lượng Parzen để dự đoán các tập
hợp siêu tham số có khả năng hoạt động tốt. Một thư viện khác có tên là Hyperas (https://
github.com/maxpumperla/hyperas) tích hợp Hyperopt để sử dụng với các mẫu Keras. Hãy kiểm tra
xem nó ra.
LƯU Ý Một vấn đề quan trọng cần lưu ý khi thực hiện tối ưu hóa siêu pa rameter tự
động ở quy mô lớn là khớp quá mức thiết lập xác thực. Vì bạn đang cập nhật siêu
tham số dựa trên tín hiệu được tính toán bằng cách sử dụng dữ liệu xác thực hợp lệ,
nên bạn đang đào tạo chúng một cách hiệu quả về dữ liệu xác thực và do đó, chúng
sẽ nhanh chóng khớp với dữ liệu xác thực. Hãy luôn ghi nhớ điều này.
Nhìn chung, tối ưu hóa siêu tham số là một kỹ thuật mạnh mẽ, là yêu cầu tuyệt đối để có được
các mô hình tiên tiến nhất trong bất kỳ nhiệm vụ nào hoặc để giành chiến thắng trong các
cuộc thi máy học. Hãy nghĩ về điều này: ngày xửa ngày xưa, mọi người đã tạo ra các tính năng
thủ công cho các mô hình học máy nông cạn. Đó là rất nhiều dưới mức tối ưu. Giờ đây, học sâu
tự động hóa nhiệm vụ của kỹ thuật tính năng phân cấp—các tính năng được học bằng cách sử
dụng tín hiệu phản hồi, không phải điều chỉnh bằng tay và đó là cách nó nên diễn ra. Theo
cách tương tự, bạn không nên làm thủ công các kiến trúc mô hình của mình; bạn nên tối ưu hóa
chúng một cách có nguyên tắc. Tại thời điểm viết bài này, lĩnh vực tối ưu hóa siêu tham số
tự động còn rất non trẻ và non nớt, giống như lĩnh vực học sâu cách đây vài năm, nhưng tôi
hy vọng lĩnh vực này sẽ bùng nổ trong vài năm tới.
7.3.3 Tập hợp mô hình

Một kỹ thuật hiệu quả khác để đạt được kết quả tốt nhất có thể cho một nhiệm vụ là tập hợp
mô hình. Tập hợp bao gồm tập hợp các dự đoán của một tập hợp các mô hình khác nhau lại với
nhau để tạo ra các dự đoán tốt hơn. Nếu bạn xem xét các cuộc thi về máy học, đặc biệt là
trên Kaggle, bạn sẽ thấy rằng những người chiến thắng sử dụng một tập hợp rất lớn các mô
hình mà chắc chắn sẽ đánh bại bất kỳ mô hình đơn lẻ nào, bất kể tốt đến đâu.

Tập hợp dựa trên giả định rằng các mô hình tốt khác nhau được đào tạo một cách độc lập có khả
năng tốt vì những lý do khác nhau: mỗi mô hình xem xét các khía cạnh hơi khác nhau của dữ liệu để
đưa ra dự đoán của nó, thu được một phần “sự thật” nhưng không phải là tất cả. Bạn có thể quen thuộc
với câu chuyện ngụ ngôn cổ xưa về người mù và con voi: một nhóm người mù lần đầu tiên bắt gặp một
con voi và cố gắng hiểu con voi là gì bằng cách chạm vào nó. Mỗi người đàn ông chạm vào một bộ phận
khác nhau trên cơ thể voi—chỉ một bộ phận, chẳng hạn như thân hoặc chân. Sau đó, những người đàn ông
mô tả cho nhau nghe con voi là gì: “Nó giống như một con rắn”, “Giống như một cái cột hay một cái
cây”, v.v.
Những người mù về cơ bản là các mô hình học máy đang cố gắng hiểu người đàn ông nếu dữ liệu đào
tạo, mỗi người từ quan điểm riêng, sử dụng các giả định của riêng mình (được cung cấp bởi kiến trúc
độc đáo của mô hình và khởi tạo trọng số ngẫu nhiên duy nhất). Mỗi người trong số họ nhận được một
phần sự thật của dữ liệu, nhưng không phải là toàn bộ sự thật. Bằng cách tổng hợp các quan điểm của
họ lại với nhau, bạn có thể có được mô tả dữ liệu chính xác hơn nhiều. Con voi là sự kết hợp của
nhiều bộ phận: không phải bất kỳ người mù nào cũng hiểu đúng, nhưng khi được phỏng vấn cùng nhau,
họ có thể kể một câu chuyện khá chính xác.
Hãy sử dụng phân loại làm ví dụ. Cách dễ nhất để tổng hợp các dự đoán của một tập hợp các bộ
phân loại (để tập hợp các bộ phân loại) là tính trung bình các dự đoán của chúng tại thời điểm suy luận:
Sử dụng bốn mô hình khác nhau để tính toán các dự đoán ban đầu.
preds_a = model_a.predict(x_val) preds_b

= model_b.predict(x_val) preds_c = Mảng dự đoán mới này phải
model_c.predict(x_val) preds_d = chính xác hơn bất kỳ mảng
model_d.predict(x_val) ban đầu nào.
final_preds = 0,25 * (preds_a + preds_b + preds_c + preds_d)
Điều này sẽ chỉ hoạt động nếu các bộ phân loại ít nhiều tốt như nhau. Nếu một trong số chúng kém
hơn đáng kể so với những cái khác, thì dự đoán cuối cùng có thể không tốt bằng bộ phân loại tốt nhất
của nhóm.
Một cách thông minh hơn để tập hợp các trình phân loại là thực hiện tính trung bình có trọng
số, trong đó các trọng số được học trên dữ liệu xác thực—thông thường, các trình phân loại tốt hơn
sẽ có trọng số cao hơn và các trình phân loại kém hơn sẽ có trọng số thấp hơn. Để tìm kiếm một tập
hợp tốt các trọng số tập hợp, bạn có thể sử dụng tìm kiếm ngẫu nhiên hoặc thuật toán tối ưu hóa đơn
giản, chẳng hạn như Nelder-Mead:
preds_a = model_a.predict(x_val)
preds_b = model_b.predict(x_val) Các trọng số này (0,5, 0,25,
preds_c = model_c.predict(x_val) 0,1, 0,15) được giả định là
preds_d = model_d.predict(x_val) học được theo kinh nghiệm.
final_preds = 0,5 * preds_a + 0,25 * preds_b + 0,1 * preds_c + 0,15 * preds_d
Có nhiều biến thể có thể xảy ra: chẳng hạn, bạn có thể tính trung bình theo cấp số nhân của các dự
đoán. Nói chung, trung bình có trọng số đơn giản với trọng số được tối ưu hóa trên dữ liệu xác thực
cung cấp cơ sở rất mạnh.
Chìa khóa để thực hiện công việc tập hợp là sự đa dạng của tập hợp các bộ phân loại. Sự đa dạng
là sức mạnh. Nếu tất cả những người mù chỉ chạm vào vòi voi, họ sẽ đồng ý

rằng con voi giống như con rắn, và họ sẽ mãi mãi không biết sự thật của con voi. Sự đa dạng là
những gì làm cho công việc tập hợp. Theo thuật ngữ học máy, nếu tất cả các mô hình của bạn đều có
xu hướng giống nhau, thì nhóm của bạn sẽ giữ nguyên xu hướng đó. Nếu các mô hình của bạn bị sai
lệch theo những cách khác nhau, thì những sai lệch đó sẽ triệt tiêu lẫn nhau và tổng thể sẽ mạnh mẽ
hơn và chính xác hơn.
Vì lý do này, bạn nên tập hợp các mô hình tốt nhất có thể trong khi càng khác biệt càng tốt.
Điều này thường có nghĩa là sử dụng các kiến trúc rất khác nhau hoặc thậm chí các nhãn hiệu phương
pháp học máy khác nhau. Một điều phần lớn không đáng làm là tập hợp cùng một mạng được đào tạo
nhiều lần một cách độc lập, từ các lần khởi tạo ngẫu nhiên khác nhau. Nếu sự khác biệt duy nhất
giữa các mô hình của bạn là khởi tạo dom chạy và thứ tự mà chúng tiếp xúc với dữ liệu đào tạo, thì
nhóm của bạn sẽ có tính đa dạng thấp và sẽ chỉ cung cấp một cải tiến nhỏ so với bất kỳ mô hình đơn
lẻ nào.
Một điều mà tôi nhận thấy là hoạt động tốt trong thực tế—nhưng điều đó không khái quát hóa cho
mọi miền vấn đề—là việc sử dụng một tập hợp các phương pháp dựa trên cây (chẳng hạn như rừng dom
chạy hoặc cây được tăng cường độ dốc) và mạng lưới thần kinh sâu. Vào năm 2014, đối tác Andrei
Kolev và tôi đã giành vị trí thứ tư trong thử thách phát hiện phân rã Higgs Boson trên Kaggle
(www.kaggle.com/c/higgs-boson) bằng cách sử dụng một tập hợp các mô hình cây khác nhau và mạng lưới
thần kinh sâu. Đáng chú ý, một trong những mô hình trong tập hợp bắt nguồn từ một phương pháp khác
so với những mô hình khác (đó là một khu rừng tham lam được chuẩn hóa) và có điểm kém hơn đáng kể
so với những mô hình khác. Không có gì đáng ngạc nhiên, nó đã được chỉ định một trọng lượng nhỏ
trong quần thể. Nhưng trước sự ngạc nhiên của chúng tôi, hóa ra nó đã cải thiện toàn bộ quần thể
lên một yếu tố lớn, bởi vì nó quá khác biệt so với mọi mô hình khác: nó cung cấp thông tin mà các
mô hình khác không có quyền truy cập. Đó chính xác là điểm tập hợp. Vấn đề không phải là mô hình
tốt nhất của bạn tốt như thế nào; đó là về sự đa dạng của tập hợp các mô hình ứng cử viên của bạn.
Trong thời gian gần đây, một phong cách tập hợp cơ bản đã rất thành công trong thực tế là phạm
trù rộng và sâu của các mô hình, kết hợp giữa học sâu và học nông. Các mô hình như vậy bao gồm
việc cùng đào tạo một mạng lưới thần kinh sâu với một mô hình tuyến tính lớn. Việc đào tạo chung
một nhóm các mô hình đa dạng là một lựa chọn khác để đạt được sự tập hợp mô hình.
7.3.4 Kết thúc

Khi xây dựng deep convnets hiệu suất cao, bạn sẽ cần sử dụng các kết nối còn lại, chuẩn hóa
hàng loạt và các kết chập có thể phân tách theo chiều sâu. Trong tương lai, có khả năng các
cấu chập có thể phân tách theo chiều sâu sẽ thay thế hoàn toàn các cấu chập thông thường,
cho dù đối với các ứng dụng 1D, 2D hay 3D , do hiệu quả biểu diễn của chúng cao hơn. Xây
dựng mạng sâu yêu cầu thực hiện nhiều lựa chọn kiến trúc và siêu tham số nhỏ, những lựa chọn
này cùng nhau xác định mức độ tốt của mô hình của bạn.
Thay vì dựa trên những lựa chọn này dựa trên trực giác hoặc cơ hội ngẫu nhiên, tốt hơn là
tìm kiếm một cách có hệ thống không gian siêu tham số để tìm ra những lựa chọn tối ưu. Tại đây

thời gian, quy trình tốn kém và công cụ thực hiện không tốt lắm. Nhưng các thư viện
Hyperopt và Hyperas có thể giúp bạn. Khi thực hiện tối ưu hóa hyperpa rameter, hãy chú
ý đến việc lắp quá mức bộ xác thực!
Giành chiến thắng trong các cuộc thi học máy hoặc đạt được kết quả tốt nhất có thể đối
với một nhiệm vụ chỉ có thể được thực hiện với các tập hợp lớn các mô hình. Kết hợp
thông qua mức trung bình có trọng số được tối ưu hóa tốt thường là đủ tốt. Hãy nhớ
rằng: sự đa dạng là sức mạnh. Phần lớn là vô nghĩa khi kết hợp các mô hình rất giống
nhau; các tập hợp tốt nhất là các tập hợp các mô hình càng khác nhau càng tốt (đồng
thời có càng nhiều khả năng dự đoán càng tốt, một cách tự nhiên).

tóm tắt chương

Trong chương này, bạn đã học những điều
sau: – Cách xây dựng mô hình dưới dạng biểu đồ lớp tùy ý, sử dụng lại lớp
(chia sẻ trọng số lớp) và sử dụng mô hình làm hàm Python (tạo mẫu mô hình).
– Bạn có thể sử dụng lệnh gọi lại Keras để giám sát các mô hình của mình trong quá trình đào tạo và
thực hiện hành động dựa trên trạng thái mô hình.
– TensorBoard cho phép bạn trực quan hóa các số liệu, biểu đồ kích hoạt và
thậm chí nhúng không gian.
– Chuẩn hóa hàng loạt, tích chập có thể phân tách theo chiều sâu và kết nối dư
là gì.
– Tại sao bạn nên sử dụng tối ưu hóa siêu tham số và tập hợp mô hình. Với
những công cụ mới này, bạn được trang bị tốt hơn để sử dụng học sâu trong thế giới
thực và bắt đầu xây dựng các mô hình học sâu có tính cạnh tranh cao.

Học sâu sáng tạo
Tạo văn bản với LSTM Triển
khai DeepDream Thực hiện
chuyển kiểu thần kinh

Bộ mã hóa tự động đa dạng
Hiểu các mạng lưới đối thủ chung
Tiềm năng của trí tuệ nhân tạo trong việc mô phỏng các quá trình suy nghĩ của con người
vượt xa các nhiệm vụ thụ động như nhận dạng đối tượng và các nhiệm vụ chủ yếu là phản ứng
như lái xe. Nó mở rộng tốt vào các hoạt động sáng tạo. Khi tôi lần đầu tiên đưa ra tuyên
bố rằng trong một tương lai không xa, hầu hết nội dung văn hóa mà chúng ta tiêu thụ sẽ
được tạo ra với sự trợ giúp đáng kể từ AI, tôi đã hoàn toàn không thể tin được, ngay cả
từ những người thực hành máy học lâu năm. Đó là vào năm 2014. Ba năm trôi qua nhanh chóng,
và sự hoài nghi đã giảm đi—với một tốc độ đáng kinh ngạc. Vào mùa hè năm 2015, chúng tôi
đã rất thích thú khi thuật toán DeepDream của Google biến một hình ảnh thành một mớ hỗn
độn ảo giác của mắt chó và các đồ tạo tác theo phong cách pareidolic; vào năm 2016, chúng
tôi đã sử dụng ứng dụng Prisma để biến những bức ảnh thành tranh vẽ với nhiều phong cách
khác nhau. Vào mùa hè năm 2016, một bộ phim ngắn thử nghiệm, Sunspring, được đạo diễn bằng
cách sử dụng một kịch bản được viết bởi thuật toán Trí nhớ ngắn hạn dài (LSTM)—hoàn chỉnh
với lời thoại. Có thể gần đây bạn đã nghe nhạc được tạo tạm thời bởi một mạng lưới thần kinh.
269

270 CHƯƠNG 8 Học sâu sáng tạo
Đúng là các sản phẩm nghệ thuật mà chúng ta đã thấy từ AI cho đến nay có chất lượng khá thấp.
AI không phải là đối thủ cạnh tranh của các nhà biên kịch, họa sĩ và nhà soạn nhạc của con người.
Nhưng việc thay thế con người luôn là vấn đề quan trọng: trí tuệ nhân tạo không phải là thay thế
trí thông minh của chính chúng ta bằng một thứ khác, mà là đưa trí thông minh vào cuộc sống và
hoạt động của chúng ta nhiều hơn —một loại trí thông minh khác. Trong nhiều lĩnh vực, nhưng đặc
biệt là trong lĩnh vực sáng tạo, AI sẽ được con người sử dụng như một công cụ để tăng cường khả
năng của chính họ: trí tuệ tăng cường hơn trí tuệ nhân tạo .
Phần lớn sáng tạo nghệ thuật bao gồm nhận dạng mẫu đơn giản và kỹ năng kỹ thuật. Và đó chính
xác là một phần của quá trình mà nhiều người thấy kém hấp dẫn hoặc thậm chí không cần thiết. Đó
là nơi AI xuất hiện. Các phương thức nhận thức, ngôn ngữ và tác phẩm nghệ thuật của chúng ta đều
có cấu trúc thống kê. Học cấu trúc này là điều mà các thuật toán học sâu vượt trội. Các mô hình
học máy có thể học không gian tiềm ẩn thống kê của hình ảnh, âm nhạc và câu chuyện, sau đó chúng
có thể lấy mẫu từ không gian này, tạo ra các tác phẩm nghệ thuật mới có các đặc điểm tương tự như
các đặc điểm mà mô hình đã thấy trong dữ liệu đào tạo của nó. Về bản chất, bản thân việc lấy mẫu
như vậy hầu như không phải là một hành động sáng tạo nghệ thuật. Đó chỉ là một hoạt động toán
học: thuật toán không có nền tảng trong cuộc sống con người, cảm xúc của con người hoặc trải
nghiệm của chúng ta về thế giới; thay vào đó, nó học hỏi từ một kinh nghiệm có ít điểm chung với
kinh nghiệm của chúng ta. Chỉ có cách giải thích của chúng tôi, với tư cách là khán giả của con
người, sẽ mang lại ý nghĩa cho những gì mô hình tạo ra. Nhưng dưới bàn tay của một nghệ sĩ lành
nghề, việc tạo thuật toán có thể được điều khiển để trở nên có ý nghĩa—và đẹp đẽ. Việc lấy mẫu
không gian tiềm ẩn có thể trở thành một chiếc cọ trao quyền cho nghệ sĩ, nâng cao khả năng sáng
tạo của chúng ta và mở rộng không gian của những gì chúng ta có thể tưởng tượng. Hơn nữa, nó có
thể làm cho việc sáng tạo nghệ thuật trở nên dễ tiếp cận hơn bằng cách loại bỏ nhu cầu về kỹ năng
kỹ thuật và thực hành—thiết lập một phương tiện biểu đạt thuần túy mới, tách biệt nghệ thuật khỏi thủ công.
Iannis Xenakis, người tiên phong có tầm nhìn về âm nhạc điện tử và thuật toán, beauti đã thể
hiện đầy đủ ý tưởng tương tự này vào những năm 1960, trong bối cảnh ứng dụng công nghệ tự động
hóa vào sáng tác âm nhạc:1
Không còn những tính toán tẻ nhạt, nhà soạn nhạc có thể cống hiến hết mình cho những vấn đề
chung mà hình thức âm nhạc mới đặt ra và khám phá những ngóc ngách của hình thức này trong
khi sửa đổi các giá trị của dữ liệu đầu vào. Ví dụ, anh ta có thể thử nghiệm tất cả các tổ
hợp nhạc cụ từ nghệ sĩ độc tấu đến dàn nhạc thính phòng, đến dàn nhạc lớn. Với sự hỗ trợ của
máy tính điện tử, nhà soạn nhạc trở thành một loại phi công: anh ta nhấn các nút, đưa ra tọa
độ và giám sát việc điều khiển một con tàu vũ trụ đang di chuyển trong không gian âm thanh,
băng qua các chòm sao âm thanh và các thiên hà mà trước đây anh ta chỉ có thể nhìn thoáng
qua như một giấc mơ xa vời.
Trong chương này, chúng ta sẽ khám phá từ nhiều góc độ tiềm năng của deep learning để nâng cao
khả năng sáng tạo nghệ thuật. Chúng tôi sẽ xem xét việc tạo dữ liệu trình tự (có thể được sử dụng
để tạo văn bản hoặc âm nhạc), DeepDream và tạo hình ảnh bằng cách sử dụng cả bộ mã hóa tự động
đa dạng và mạng đối thủ tạo. Chúng tôi sẽ khiến máy tính của bạn tạo ra những nội dung chưa từng
thấy trước đây; và có thể chúng tôi cũng sẽ khiến bạn mơ mộng về những khả năng tuyệt vời của
người hâm mộ nằm ở sự giao thoa giữa công nghệ và nghệ thuật. Bắt đầu nào.
1
Iannis Xenakis, “Musiques formelles: nouveaux principes formels de composition musicale,” số đặc biệt của tạp chí
La Revue musicale, số. 253 -254 (1963).

Tạo văn bản với LSTM 271
8.1 Tạo văn bản với LSTM

Trong phần này, chúng ta sẽ khám phá cách các mạng thần kinh hồi quy có thể được sử dụng để tạo
dữ liệu chuỗi. Chúng tôi sẽ sử dụng việc tạo văn bản làm ví dụ, nhưng các kỹ thuật chính xác
giống như vậy có thể được khái quát hóa cho bất kỳ loại dữ liệu trình tự nào: bạn có thể áp
dụng nó cho trình tự các nốt nhạc để tạo ra bản nhạc mới, cho chuỗi thời gian của dữ liệu nét
vẽ (ví dụ: được ghi lại trong khi một họa sĩ vẽ trên iPad) để tạo các bức tranh theo từng nét
vẽ, v.v.
Việc tạo dữ liệu trình tự không bị giới hạn trong việc tạo nội dung nghệ thuật. Nó đã được
áp dụng thành công để tổng hợp giọng nói và tạo đối thoại cho các bot trò chuyện. Tính năng Trả
lời thông minh mà Google phát hành vào năm 2016, có khả năng tự động tạo lựa chọn trả lời nhanh
cho email hoặc tin nhắn văn bản, được hỗ trợ bởi các kỹ thuật tương tự.
8.1.1 Sơ lược về lịch sử của các mạng hồi quy tổng quát
Vào cuối năm 2014, rất ít người từng nhìn thấy LSTM viết tắt, ngay cả trong cộng đồng máy học.
Các ứng dụng thành công của việc tạo dữ liệu trình tự với các công việc mạng lặp lại chỉ bắt
đầu xuất hiện trong dòng chính vào năm 2016. Nhưng những kỹ thuật này đã có một lịch sử khá
dài, bắt đầu với sự phát triển của thuật toán LSTM vào năm 1997.2 Thuật toán mới này đã sớm
được sử dụng để tạo ký tự văn bản theo ký tự.

Năm 2002, Douglas Eck, khi đó đang làm việc tại phòng thí nghiệm của Schmidhuber ở Thụy Sĩ,
lần đầu tiên áp dụng LSTM để tạo ra âm nhạc với những kết quả đầy hứa hẹn. Eck hiện là nhà
nghiên cứu tại Google Brain và vào năm 2016, anh ấy đã bắt đầu một nhóm nghiên cứu mới ở đó, có
tên là Magenta, tập trung vào việc áp dụng các kỹ thuật học sâu hiện đại để tạo ra âm nhạc hấp dẫn.
Đôi khi, những ý tưởng hay phải mất 15 năm để bắt đầu.
Vào cuối những năm 2000 và đầu những năm 2010, Alex Graves đã thực hiện công việc tiên
phong quan trọng trong việc sử dụng các mạng lặp lại để tạo dữ liệu chuỗi. Đặc biệt, công trình
năm 2013 của anh ấy về việc áp dụng các mạng mật độ hỗn hợp lặp lại để tạo ra chữ viết tay
giống người bằng cách sử dụng chuỗi thời gian của các vị trí đặt bút được một số người coi là
một bước ngoặt. trong số những cỗ máy mơ ước và là nguồn cảm hứng đáng kể trong khoảng thời
gian tôi bắt đầu phát triển Keras. Graves đã để lại một nhận xét tương tự được ẩn trong một tệp
LaTeX 2013 được tải lên máy chủ in sẵn arXiv: “tạo dữ liệu tuần tự là cách máy tính mơ ước
nhất.” Vài năm sau, chúng tôi coi nhiều giải pháp phát triển này là hiển nhiên; nhưng vào thời
điểm đó, thật khó để xem các màn trình diễn của Graves và không bỏ đi vì kinh ngạc trước những
khả năng có thể xảy ra.
Kể từ đó, các mạng thần kinh hồi quy đã được sử dụng thành công để tạo nhạc, tạo đối thoại,
tạo hình ảnh, tổng hợp giọng nói và thiết kế phân tử.
Chúng thậm chí còn được sử dụng để sản xuất một kịch bản phim sau đó được chọn với các diễn viên trực tiếp.
2
Sepp Hochreiter và Jürgen Schmidhuber, “Long Short-Term Memory,” Neural Computation 9, không. 8 (1997).
3
Alex Graves, “Tạo trình tự với mạng thần kinh tái phát,” arXiv (2013), https://arxiv.org/ abs/1308.0850.

8.1.2 Bạn tạo dữ liệu trình tự như thế nào?
Cách phổ biến để tạo dữ liệu trình tự trong deep learning là đào tạo mạng (thường là RNN hoặc
convnet) để dự đoán mã thông báo tiếp theo hoặc một vài mã thông báo tiếp theo trong một
chuỗi, sử dụng mã thông báo trước đó làm đầu vào. Chẳng hạn, với đầu vào “con mèo đang ở trên
ma”, mạng được đào tạo để dự đoán mục tiêu t, ký tự tiếp theo. Như thường lệ khi làm việc với
dữ liệu văn bản, mã thông báo thường là từ hoặc ký tự và bất kỳ mạng nào có thể lập mô hình
xác suất của mã thông báo tiếp theo dựa trên mã thông báo trước đó được gọi là mô hình ngôn
ngữ. Một mô hình ngôn ngữ nắm bắt không gian tiềm ẩn của ngôn ngữ: cấu trúc thống kê của nó.
Khi bạn đã có một mô hình ngôn ngữ được đào tạo như vậy, bạn có thể lấy mẫu từ nó (tạo
các chuỗi mới): bạn cung cấp cho nó một chuỗi văn bản ban đầu (được gọi là dữ liệu điều kiện),
yêu cầu nó tạo ký tự tiếp theo hoặc từ tiếp theo (thậm chí bạn có thể tạo nhiều mã thông báo
cùng một lúc), thêm đầu ra được tạo trở lại dữ liệu đầu vào và lặp lại quy trình nhiều lần
(xem hình 8.1). Vòng lặp này cho phép bạn tạo các chuỗi có độ dài tùy ý phản ánh cấu trúc của
dữ liệu mà mô hình được đào tạo: các chuỗi trông gần giống như các câu do con người viết.
Trong ví dụ chúng tôi trình bày trong phần này, bạn sẽ lấy một lớp LSTM , cung cấp cho nó các
chuỗi N ký tự được trích xuất từ kho văn bản và huấn luyện nó để dự đoán ký tự N + 1. Đầu ra
của mô hình sẽ là một softmax trên tất cả các ký tự có thể: phân phối xác suất cho ký tự tiếp
theo. LSTM này được gọi là mô hình ngôn ngữ thần kinh cấp ký tự.
Phân phối xác

suất cho ký tự tiếp theo Lấy mẫu ký tự tiếp
văn bản ban đầu văn bản ban đầu theo
Mô hình ngôn chiến lược

Con mèo ngồi trên m một
ngữ lấy mẫu
Mô hình ngôn chiến lược

Con mèo ngồi trên ma t
ngữ lấy mẫu
...
Hình 8.1 Quá trình tạo văn bản theo từng ký tự bằng mô hình ngôn ngữ
8.1.3 Tầm quan trọng của chiến lược lấy mẫu
Khi tạo văn bản, cách bạn chọn ký tự tiếp theo là cực kỳ quan trọng. Một cách tiếp cận ngây
thơ là lấy mẫu tham lam, bao gồm luôn chọn ký tự tiếp theo có khả năng nhất. Nhưng cách tiếp
cận như vậy dẫn đến các chuỗi lặp đi lặp lại, có thể dự đoán được, trông không giống ngôn ngữ
mạch lạc. Một cách tiếp cận thú vị hơn tạo ra các lựa chọn đáng ngạc nhiên hơn một chút: nó
giới thiệu tính ngẫu nhiên trong quy trình lấy mẫu, bằng cách lấy mẫu từ phân phối xác suất
cho ký tự tiếp theo. Điều này được gọi là lấy mẫu ngẫu nhiên (hãy nhớ rằng tính ngẫu nhiên là
cái mà chúng ta gọi là tính ngẫu nhiên trong lĩnh vực này). Trong một thiết lập như vậy, nếu
e có xác suất 0,3 là ký tự tiếp theo, theo mô hình, bạn sẽ chọn nó

30% thời gian. Lưu ý rằng lấy mẫu tham lam cũng có thể được coi là lấy mẫu từ phân phối
khả năng xác suất: một trong đó một ký tự nhất định có xác suất 1 và tất cả các ký tự
khác có xác suất 0.
Lấy mẫu theo xác suất từ đầu ra softmax của mô hình rất gọn gàng: nó cho phép đôi khi
lấy mẫu cả những ký tự không chắc chắn, tạo ra các câu trông thú vị hơn và đôi khi thể
hiện sự sáng tạo bằng cách nghĩ ra những từ mới, nghe có vẻ thực tế không xuất hiện trong
dữ liệu huấn luyện. Nhưng có một vấn đề với chiến lược này: nó không đưa ra cách kiểm
soát mức độ ngẫu nhiên trong quy trình lấy mẫu.
Tại sao bạn muốn nhiều hơn hoặc ít ngẫu nhiên hơn? Hãy xem xét một trường hợp cực
đoan: lấy mẫu ngẫu nhiên thuần túy, trong đó bạn rút ra ký tự tiếp theo từ phân phối xác
suất đồng nhất và mọi ký tự đều có khả năng như nhau. Sơ đồ này có tính ngẫu nhiên tối
đa; nói cách khác, phân phối xác suất này có entropy cực đại. Đương nhiên, nó sẽ không
tạo ra bất cứ điều gì thú vị. Ở một thái cực khác, lấy mẫu tham lam cũng không tạo ra điều
gì thú vị và không có tính ngẫu nhiên: phân phối xác suất tương ứng có entropy nhỏ nhất.
Việc lấy mẫu từ phân phối xác suất “thực”—phân phối được tạo ra bởi hàm softmax của mô
hình—tạo thành một điểm trung gian giữa hai thái cực này. Nhưng có nhiều điểm trung gian
khác của entropy cao hơn hoặc thấp hơn mà bạn có thể muốn khám phá. Ít entropy hơn sẽ
mang lại cho các chuỗi được tạo ra một cấu trúc dễ dự đoán hơn (và do đó chúng sẽ có khả
năng trông thực tế hơn), trong khi nhiều entropy hơn sẽ dẫn đến các chuỗi sáng tạo và
đáng ngạc nhiên hơn. Khi lấy mẫu từ các mô hình tổng quát, bạn nên khám phá các mức độ
ngẫu nhiên khác nhau trong quá trình tạo. Bởi vì chúng ta—con người—là người đánh giá cuối
cùng về mức độ thú vị của dữ liệu được tạo ra, nên tính thú vị mang tính chủ quan cao và
không thể nói trước điểm của entropy tối ưu nằm ở đâu.
Để kiểm soát mức độ ngẫu nhiên trong quá trình lấy mẫu, chúng tôi sẽ giới thiệu một
tham số gọi là nhiệt độ softmax đặc trưng cho entropy của phân bố xác suất được sử dụng
để lấy mẫu: nó đặc trưng cho mức độ ngạc nhiên hoặc khả năng dự đoán của việc lựa chọn ký
tự tiếp theo. thì là ở. Cho trước một giá trị nhiệt độ , phân phối xác suất mới được tính
toán từ giá trị ban đầu (đầu ra softmax của mô hình) bằng cách điều chỉnh lại trọng số
của nó theo cách sau.
Liệt kê 8.1 Điều chỉnh lại phân phối xác suất cho một nhiệt độ khác
def reweight_distribution( original_distribution, temperature=0.5): phân phối =

np.log( original_distribution) / phân phối nhiệt độ = np.exp(phân phối) phân phối trở lại /
np.sum(phân phối)
Trả về một phiên bản được điều

original_distribution là một mảng 1D chỉnh lại của bản phân phối ban đầu.
Numpy gồm các giá trị xác suất phải có Tổng của phân phối có thể không còn
tổng bằng 1. nhiệt độ là một yếu tố định là 1 nữa, vì vậy bạn chia nó cho
lượng entropy của phân phối đầu ra. tổng của nó để có được phân phối mới.

Nhiệt độ cao hơn dẫn đến phân phối lấy mẫu của entropy cao hơn sẽ tạo ra nhiều dữ liệu được tạo
phi cấu trúc và đáng ngạc nhiên hơn, trong khi nhiệt độ thấp hơn sẽ dẫn đến tình trạng domness
ít chạy hơn và dữ liệu được tạo ra dễ dự đoán hơn nhiều (xem hình 8.2).
nhiệt độ = 0,01 nhiệt độ = 0,2 nhiệt độ = 0,4
phần
suất
mẫu
lấy
của
Xác
tử
Các phần tử rời rạc (ký tự)
nhiệt độ = 0,6 nhiệt độ = 0,8 nhiệt độ = 1,0
Hình 8.2 Các cách tính lại trọng số khác nhau của một phân bố xác suất. Nhiệt độ thấp = xác định hơn,
nhiệt độ cao = ngẫu nhiên hơn.
8.1.4 Triển khai tạo văn bản LSTM cấp ký tự
Hãy áp dụng những ý tưởng này vào thực tế trong triển khai Keras. Điều đầu tiên bạn cần là rất
nhiều dữ liệu văn bản mà bạn có thể sử dụng để học một mô hình ngôn ngữ. Bạn có thể sử dụng bất
kỳ tệp văn bản hoặc tập hợp tệp văn bản đủ lớn nào—Wikipedia, Chúa tể của những chiếc nhẫn, v.v.
Trong ví dụ này, bạn sẽ sử dụng một số tác phẩm của Nietzsche, triết gia người Đức cuối thế kỷ
19 (được dịch sang tiếng Anh). Do đó, mô hình ngôn ngữ mà bạn sẽ học sẽ là mô hình cụ thể về
phong cách viết của Nietzsche và các chủ đề được lựa chọn, chứ không phải là mô hình ngôn ngữ
tiếng Anh chung chung hơn.
CHUẨN BỊ DỮ LIỆU
Hãy bắt đầu bằng cách tải xuống kho văn bản và chuyển đổi nó thành chữ thường.
Liệt kê 8.2 Tải xuống và phân tích tệp văn bản ban đầu
nhập máy ảnh nhập

numpy dưới dạng np
đường dẫn = keras.utils.get_file(

'nietzsche.txt',
origin='https://s3.amazonaws.com/text-datasets/nietzsche.txt')
text = open(path).read().lower() print('Độ dài
văn bản:', len(text))

Tiếp theo, bạn sẽ trích xuất một phần các chuỗi chồng chéo có độ dài tối đa, mã hóa một lần nóng và đóng gói
chúng trong một mảng 3D Numpy x có hình dạng (các chuỗi, maxlen, unique_characters). Đồng thời, bạn sẽ chuẩn
bị một mảng y chứa các mục tiêu phản hồi tương ứng: các ký tự được mã hóa một lần nóng xuất hiện sau mỗi lần
trích xuất
sự liên tiếp.
Liệt kê 8.3 Vector hóa các chuỗi ký tự
Bạn sẽ trích xuất các

chuỗi gồm 60 ký tự.
tối đa = 60
Bạn sẽ lấy mẫu một chuỗi mới
bước = 3 cứ sau ba ký tự.
câu = [] Giữ các chuỗi được trích xuất
next_chars = []
Giữ các mục tiêu (các
cho i trong phạm vi(0, len(text) - maxlen, step): câu.append(text[i: ký tự tiếp theo)
i + maxlen]) next_chars.append(text[i + maxlen])

Danh sách các ký tự duy
nhất trong ngữ liệu
print('Số thứ tự:', len(câu))

Từ điển ánh xạ các ký
chars = sorted(list(set(text))) print('Ký tự duy tự duy nhất vào chỉ mục của
chúng trong danh sách “ký tự”
nhất:', len(chars)) char_indices = dict((char,
chars.index(char)) cho char trong chars)
print('Vector hóa...')
x = np.zeros((len(câu), maxlen, len(ký tự)), dtype=np.bool)
y = np.zeros((len(câu), len(ký tự)), dtype=np.bool)

One-hot mã hóa
đối với i, câu ở dạng liệt kê (câu): đối với t, char ở dạng
các ký tự thành
liệt kê (câu): x[i, t, char_indices[char]] = 1 y[i,
các mảng nhị phân
char_indices[next_chars[i]]] = 1
XÂY DỰNG MẠNG LƯỚI
Mạng này là một lớp LSTM duy nhất , theo sau là bộ phân loại Mật độ cao và softmax trên tất cả các ký tự có
thể. Nhưng lưu ý rằng các mạng thần kinh tái phát không phải là cách duy nhất để tạo dữ liệu chuỗi; Convnets
1D cũng đã được chứng minh là cực kỳ thành công trong nhiệm vụ này trong thời gian gần đây.
Liệt kê 8.4 Mô hình LSTM một lớp để dự đoán ký tự tiếp theo
model = keras.models.Sequential()
model.add(layers.LSTM(128, input_shape=(maxlen, len(chars)))) model.add(layers.Dense(len(chars),
activation='softmax') )

Bởi vì các mục tiêu của bạn được mã hóa một lần nóng, nên bạn sẽ sử dụng categorical_crossentropy
làm tổn thất để huấn luyện mô hình.
Liệt kê 8.5 Cấu hình biên dịch mô hình
trình tối ưu hóa = keras.optimizers.RMSprop(lr=0.01)

model.compile(loss='categorical_crossentropy', Optimizer=optimizer)
ĐÀO TẠO MÔ HÌNH NGÔN NGỮ VÀ LẤY MẪU TỪ NÓ
Với một mô hình đã được đào tạo và một đoạn văn bản gốc, bạn có thể tạo văn bản mới bằng cách lặp
đi lặp lại thao tác sau:
1 Rút ra từ mô hình một phân phối xác suất cho ký tự tiếp theo, cho trước
văn bản được tạo có sẵn cho đến nay.
2 Cân lại phân phối đến một nhiệt độ nhất định.
3 Lấy mẫu ký tự tiếp theo một cách ngẫu nhiên theo phân phối được tính lại.
4 Thêm ký tự mới vào cuối văn bản có sẵn.
Đây là mã bạn sử dụng để tính lại phân phối xác suất ban đầu ra khỏi mô hình và rút ra một chỉ số
ký tự từ nó ( hàm lấy mẫu).
Liệt kê 8.6 Chức năng lấy mẫu ký tự tiếp theo cho các dự đoán của mô hình
mẫu def (dự đoán, nhiệt độ = 1,0):

preds = np.asarray(preds).astype('float64') preds = np.log(preds) /
nhiệt độ exp_preds = np.exp(preds) preds = exp_preds /
np.sum(exp_preds) probas = np.random.multinomial (1, số lần đặt
trước, 1) trả về np.argmax(probas)
Cuối cùng, vòng lặp sau liên tục đào tạo và tạo văn bản. Bạn bắt đầu tạo văn bản bằng cách sử dụng
một loạt nhiệt độ khác nhau sau mỗi kỷ nguyên. Điều này cho phép bạn xem văn bản được tạo phát
triển như thế nào khi mô hình bắt đầu hội tụ, cũng như tác động của nhiệt độ trong chiến lược lấy
mẫu.
Liệt kê 8.7 Vòng lặp tạo văn bản
nhập ngẫu nhiên

nhập sys Huấn luyện mô hình trong 60 kỷ nguyên
đối với kỷ nguyên trong phạm vi (1, Phù hợp với mô hình cho một lần lặp
60): print('epoch', epoch) trên dữ liệu
model.fit(x, y, batch_size=128, epochs=1) start_index =

random.randint(0, len(text) - maxlen - 1 ) created_text = text[start_index: Chọn một hạt giống
văn bản một cách ngẫu

start_index + maxlen] print('--- Đang tạo với hạt giống: "' + created_text + '"')
nhiên
đối với nhiệt độ trong [0,2, 0,5, 1,0, 1,2]:

Thử một loạt các nhiệt
print('------ nhiệt độ:', nhiệt độ) sys.stdout.write(generated_text)
độ lấy mẫu khác nhau

for i in range(400): lấy mẫu =

Tạo 400 ký
np.zeros((1, maxlen, len(chars))) for t, char in Mã hóa một lần
tự, bắt
enumerate(generated_text): các ký tự được
đầu từ văn
bản gốc đã lấy mẫu[0, t, char_indices[char]] = 1. tạo cho đến nay
preds = model.predict(sampled, verbose=0)[0] next_index = sample(preds, Lấy mẫu

temperature) next_char = chars[next_index] ký tự
tiếp theo
văn bản được tạo += next_char được tạo_văn
bản = văn bản được tạo [1:]
sys.stdout.write(next_char)
Ở đây, chúng tôi đã sử dụng văn bản hạt giống ngẫu nhiên “khoa mới, và sự hân hoan đạt đến
đỉnh điểm khi kant.” Đây là những gì bạn nhận được ở kỷ nguyên 20, rất lâu trước khi mô hình
hội tụ hoàn toàn, với nhiệt độ = 0,2:
năng lực mới, và sự hân hoan đạt đến đỉnh điểm khi Kant và một người đàn ông như vậy đồng thời là tinh thần của cái chắc
chắn và cái như vậy của một người đàn ông là ánh sáng mặt trời và đặt hiện tại vào ưu thế của nỗi đau đặc biệt nhất của
con người và kỳ lạ sự khuất phục của lương tâm đặc biệt, bản chất đặc biệt và những người như vậy, sự khuất phục của
những người đặc biệt, chắc chắn nhất là sự khuất phục của trí tuệ đặc biệt, sự khuất phục của những thứ tương tự và
Đây là kết quả với nhiệt độ = 0,5:
quan năng mới, và sự hân hoan lên đến đỉnh điểm khi Kant trong cái vĩnh cửu và con người như vậy cũng trở thành tình
trạng của chính mình.
kinh nghiệm về sự vượt trội và sức mạnh đặc biệt của sức mạnh, trong ngôn ngữ, mà cuộc sống đồng thời và "ngay
cả những người không phân biệt nhân loại, với một chủ đề và thực tế, tất cả những gì bạn phải là đứng và không
có một sự đối xử của con người và chắc chắn lương tâm là ưu việt, và khi một người phải
Và đây là những gì bạn nhận được với nhiệt độ = 1,0:
khoa mới, và sự hân hoan lên đến đỉnh điểm khi kant, như một sự hủy hoại của mọi cách thức đối với tất cả
các định nghĩa và nhìn nhận nó, nó rất vui nhộn và bắt anh ta tiếp tục nghệ thuật
cũng giống như nếu có bao giờ sự ủng hộ để tạo ra như cnecience. để được juden, tất cả mọi thứ có thể lạnh
lùng giống như một cuộc sống thụ động, những lớp giống như vậy có thể là tài khoản, sự nảy mầm thờ ơ, rằng mọi
thứ đều có sự hủy diệt nhất định, trí tuệ trở thành nguồn gốc xấu xa của đạo đức, và một sự kém cỏi hơn
Ở kỷ nguyên 60, mô hình gần như đã hội tụ và văn bản bắt đầu trông mạch lạc hơn đáng kể. Đây
là kết quả với nhiệt độ = 0,2:
sự vui vẻ, thân thiện và lòng tốt của một trái tim là cảm giác của tinh thần là một người đàn ông có ý thức về thế
giới của sự tự kết thúc và tự liên quan đến sự khuất phục của sức mạnh -

sự khuất phục của sự khuất phục của sự khuất phục của những cảm xúc liên quan đến bản
thân trong sự vượt trội trong sự khuất phục của sự khuất phục của tinh thần không phải là một người đàn ông của cảm
giác bị khuất phục và được cho là sức mạnh của cảm giác bị khuất phục
Đây là nhiệt độ = 0,5:
sự vui vẻ, thân thiện và lòng tốt của một trái tim là một phần của tâm hồn đã từng là nghệ thuật của các triết gia, và
điều mà người ta sẽ không nói, đó là điều gì cao hơn và với tôn giáo của các pháp. cuộc sống của tinh thần trong số những
gì còn lại nhất của sức mạnh của ý thức, lương tâm của những người đàn ông có đủ tự tin trước khi đủ tự tin, và cả loài
người, và một cái gì đó là các quan niệm, sự khuất phục của ý thức và đau khổ và
Và đây là nhiệt độ = 1,0:
sự vui vẻ, thân thiện và lòng tốt của một trái tim là tinh thần bởi văn hóa đối với những người say mê, anh ấy đã
gây ngạc nhiên, hoặc những sai lầm đối với chúng tôi mà bạn đã hiểu - và nó cần, để suy nghĩ từng chút một cho
toàn bộ hoạt động của những người mới đến, những người hoàn hảo! đó là
name, for example but voludd atu-especity"--or rank onee, or even all "solett increessic of the world and
kinh nghiệm bi kịch, transf, hoặc nội bộ,--phải có nếu mong muốn của strubction là mạnh mẽ
Như bạn có thể thấy, giá trị nhiệt độ thấp dẫn đến văn bản cực kỳ lặp lại và dễ đoán, nhưng
cấu trúc cục bộ lại rất thực tế: đặc biệt, tất cả các từ (một từ là một mẫu ký tự cục bộ) đều
là những từ tiếng Anh thực sự. Với nhiệt độ cao hơn, văn bản được tạo ra trở nên thú vị, đáng
ngạc nhiên, thậm chí sáng tạo hơn; đôi khi nó phát minh ra những từ hoàn toàn mới nghe có vẻ
hợp lý (chẳng hạn như vĩnh cửu và troveration ).
Với nhiệt độ cao, cấu trúc cục bộ bắt đầu bị phá vỡ và hầu hết các từ trông giống như các chuỗi
ký tự bán ngẫu nhiên. Không còn nghi ngờ gì nữa, 0,5 là nhiệt độ thú vị nhất để tạo văn bản
trong thiết lập cụ thể này. Luôn thử nghiệm với nhiều chiến lược lấy mẫu! Sự cân bằng thông
minh giữa cấu trúc đã học và tính ngẫu nhiên là điều khiến thế hệ trở nên thú vị.
Lưu ý rằng bằng cách đào tạo một mô hình lớn hơn, lâu hơn, trên nhiều dữ liệu hơn, bạn có
thể đạt được các mẫu được tạo trông mạch lạc và thực tế hơn nhiều so với mẫu này. Tuy nhiên,
tất nhiên, đừng mong đợi tạo ra bất kỳ văn bản có ý nghĩa nào, ngoại trừ cơ hội ngẫu nhiên:
tất cả những gì bạn đang làm là lấy mẫu dữ liệu từ một mô hình thống kê xem các ký tự nào theo
sau ký tự nào. Ngôn ngữ là một kênh giao tiếp và có sự khác biệt giữa nội dung giao tiếp và
cấu trúc thống kê của
các tin nhắn trong đó thông tin liên lạc được mã hóa. Để chứng minh sự khác biệt này, đây là
một thử nghiệm tưởng tượng: điều gì sẽ xảy ra nếu ngôn ngữ con người thực hiện công việc nén
thông tin liên lạc tốt hơn, giống như máy tính làm với hầu hết các thông tin liên lạc kỹ thuật số?
Ngôn ngữ sẽ không kém phần ý nghĩa, nhưng nó sẽ thiếu bất kỳ cấu trúc thống kê nội tại nào,
do đó không thể học một mô hình ngôn ngữ như bạn vừa làm.

8.1.5 Kết thúc

Bạn có thể tạo dữ liệu chuỗi rời rạc bằng cách đào tạo một mô hình để dự đoán (các) mã thông báo
tiếp theo, dựa trên các mã thông báo trước đó. Trong trường hợp văn bản, mô hình như vậy được
gọi là mô hình ngôn ngữ. Nó có thể được dựa trên

hoặc từ hoặc ký tự.
Lấy mẫu mã thông báo tiếp theo yêu cầu cân bằng giữa việc tuân theo những gì mô hình
đánh giá có khả năng, và giới thiệu tính ngẫu nhiên.
Một cách để giải quyết vấn đề này là khái niệm về nhiệt độ softmax. Luôn trải nghiệm
ment với nhiệt độ khác nhau để tìm đúng.

8.2 Giấc mơ sâu

DeepDream là một kỹ thuật sửa đổi hình ảnh nghệ thuật sử dụng các biểu diễn được học bởi các
mạng thần kinh tích chập. Nó được Google phát hành lần đầu tiên vào mùa hè năm 2015, dưới
dạng triển khai được viết bằng thư viện học sâu Caffe (việc này diễn ra vài tháng trước khi
TensorFlow được phát hành công khai lần đầu tiên).4 Nó nhanh chóng trở thành cơn sốt trên
internet nhờ những bức ảnh đẹp mắt nó có thể tạo ra (ví dụ: xem hình 8.3), chứa đầy các tạo
tác pareidolia theo thuật toán, lông chim và mắt chó—một sản phẩm phụ của thực tế là
DeepDream convnet đã được đào tạo trên ImageNet, nơi các giống chó và loài chim được đại
diện rất nhiều.
Hình 8.3 Ví dụ về hình ảnh đầu ra DeepDream
Thuật toán DeepDream hầu như giống hệt với kỹ thuật trực quan hóa bộ lọc convnet được giới
thiệu trong chương 5, bao gồm chạy ngược lại một convnet: thực hiện tăng dần trên đầu vào
của convnet để tối đa hóa việc kích hoạt một bộ lọc cụ thể ở tầng trên. lớp của convnet.
DeepDream sử dụng cùng ý tưởng này, với một vài điểm khác biệt đơn giản:
Với DeepDream, bạn cố gắng tối đa hóa việc kích hoạt toàn bộ các lớp chứ không phải
của một bộ lọc cụ thể, do đó trộn lẫn các hình ảnh trực quan hóa của một số lượng lớn
các tính năng cùng một lúc.
4
Alexander Mordvintsev, Christopher Olah và Mike Tyka, “DeepDream: A Code Example for Visualizing Neural
Networks,” Google Research Blog, ngày 1 tháng 7 năm 2015, http://mng.bz/xXlM.

giấc mơ sâu 281
Bạn không bắt đầu từ đầu vào trống, hơi nhiễu, mà là từ một hình ảnh hiện có—
do đó, các hiệu ứng kết quả sẽ bám vào các mẫu hình ảnh có sẵn, làm biến dạng
các yếu tố của hình ảnh theo một cách hơi nghệ thuật.
Các hình ảnh đầu vào được xử lý ở các tỷ lệ khác nhau (được gọi là quãng tám), mà
cải thiện chất lượng của các hình ảnh.
Hãy tạo một số DeepDreams.
8.2.1 Triển khai DeepDream trong Keras
Bạn sẽ bắt đầu từ một convnet được đào tạo trước trên ImageNet. Trong Keras, có nhiều kết nối như vậy: VGG16, VGG19,
Xception, ResNet50, v.v. Bạn có thể triển khai Deep Dream với bất kỳ mạng nào trong số chúng, nhưng mạng kết nối
bạn chọn sẽ tự nhiên ảnh hưởng đến hình ảnh của bạn, bởi vì các kiến trúc mạng kết nối khác nhau dẫn đến các tính
năng đã học khác nhau. Convnet được sử dụng trong bản phát hành DeepDream ban đầu là một mô hình Inception và trên
thực tế, Inception được biết là tạo ra các DeepDream đẹp mắt, vì vậy bạn sẽ sử dụng mô hình Incep tion V3 đi kèm
với Keras.
Liệt kê 8.8 Đang tải mô hình Inception V3 được đào tạo trước
từ keras.applications nhập inception_v3 từ keras nhập phụ trợ

Bạn sẽ không đào tạo mô hình, vì vậy
dưới dạng K
lệnh này sẽ vô hiệu hóa tất cả các
K.set_learning_phase(0) hoạt động đào tạo cụ thể.
model = inception_v3.InceptionV3(weights='imagenet', Xây dựng mạng Inception V3 mà không

có cơ sở tích chập.
bao gồm_top=Sai)
Mô hình sẽ được tải với các
trọng số ImageNet được đào tạo trước.
Tiếp theo, bạn sẽ tính toán tổn thất: số lượng bạn sẽ tìm cách tối đa hóa trong quá trình
tăng dần độ dốc. Trong chương 5, để trực quan hóa bộ lọc, bạn đã cố gắng tối đa hóa giá trị
của một bộ lọc cụ thể trong một lớp cụ thể. Tại đây, bạn sẽ kích hoạt tối đa đồng thời tất cả
các bộ lọc trong một số lớp. Cụ thể, bạn sẽ tối đa hóa tổng trọng số của định mức L2 về số
lần kích hoạt của một tập hợp các lớp cấp cao. Tập hợp chính xác các lớp bạn chọn (cũng như
đóng góp của chúng vào tổn thất cuối cùng) có ảnh hưởng lớn đến hình ảnh mà bạn có thể tạo
ra, vì vậy bạn muốn làm cho các tham số này có thể dễ dàng định cấu hình. Các lớp thấp hơn
tạo ra các mẫu hình học, trong khi các lớp cao hơn tạo ra hình ảnh mà bạn có thể nhận ra một
số lớp từ ImageNet (ví dụ: chim hoặc chó). Bạn sẽ bắt đầu từ một cấu hình hơi tùy ý bao gồm
bốn lớp—nhưng chắc chắn bạn sẽ muốn khám phá nhiều cấu hình khác nhau sau này.
Liệt kê 8.9 Thiết lập cấu hình DeepDream
layer_contributions = { 'mixed2':
Các tên lớp ánh xạ từ điển thành một hệ số định lượng mức độ
0.2, 'mixed3': 3., 'mixed4':
kích hoạt của lớp góp phần vào sự mất mát mà bạn sẽ tìm cách tối
2., 'mixed5': 1.5,
đa hóa. Lưu ý rằng tên lớp được mã hóa cứng trong ứng dụng
Inception V3 tích hợp sẵn. Bạn có thể liệt kê tất cả các tên lớp
bằng cách sử dụng model.summary().
}

Bây giờ, hãy xác định một tenxơ chứa tổn thất: tổng trọng số của chuẩn L2 của các kích hoạt
của các lớp trong danh sách 8.9.
Liệt kê 8.10 Xác định tổn thất được tối đa hóa
Tạo một từ điển ánh xạ tên lớp cho

các thể hiện của lớp
layer_dict = dict([(layer.name, layer) cho lớp trong model.layers])
loss = K.variable(0.) for

Bạn sẽ xác định tổn thất bằng cách
layer_name trong layer_contributions:
thêm các đóng góp của lớp vào biến
coeff = layer_contributions[layer_name] activation = vô hướng này.
layer_dict[layer_name].output
tỷ lệ = K.prod(K.cast(K.shape(kích hoạt), 'float32')) mất += coeff * K.sum(K.square(kích
hoạt[:, 2: -2, 2: -2, : ])) / chia tỷ lệ
Thêm định mức L2 của các tính năng của một lớp vào
Truy xuất đầu ra của lớp tổn thất. Bạn tránh các tạo tác đường viền bằng
cách chỉ liên quan đến các pixel không viền trong mất mát.
Tiếp theo, bạn có thể thiết lập quy trình tăng độ dốc.
Liệt kê 8.11 Quá trình tăng dần độ dốc
Tenxơ này giữ hình ảnh
được tạo ra: giấc mơ. Tính toán độ dốc của giấc mơ liên
quan đến sự mất mát
giấc mơ = model.input
grads = K.gradients(mất, mơ)[0]

Bình thường hóa độ dốc (thủ
thuật quan trọng)
grads /= K.maximum(K.mean(K.abs(grads)), 1e-7)
đầu ra = [mất, grads]
fetch_loss_and_grads = K.function([dream], đầu ra) Thiết lập hàm Keras để

truy xuất giá trị của sự
def eval_loss_and_grads(x): outs = mất mát và độ dốc, được
fetch_loss_and_grads([x]) loss_value = outs[0] cung cấp một hình ảnh đầu vào
grad_values = outs[1] return loss_value, grad_values
def gradient_ascent(x, lần lặp, bước, max_loss=Không):
cho tôi trong phạm vi (lặp lại):
loss_value, grad_values = eval_loss_and_grads(x) nếu max_loss không phải là Chức năng này chạy
Không và loss_value > max_loss:
tăng dần độ dốc cho một
nghỉ số lần lặp lại.
print('...Giá trị mất tại', i, ':', loss_value) x += trả về bước x
* grad_values
Cuối cùng: thuật toán DeepDream thực tế. Đầu tiên, bạn xác định một danh sách các thang (còn
gọi là quãng tám) để xử lý ảnh. Mỗi tỷ lệ kế tiếp lớn hơn tỷ lệ trước đó theo hệ số 1,4 (lớn
hơn 40%): bạn bắt đầu bằng cách xử lý một hình ảnh nhỏ và sau đó tăng dần tỷ lệ lên (xem hình
8.4).

giấc mơ sâu 283
tiêm
tiêm lại chi tiết
lại chi tiết
Mơ cao cấp Mơ cao cấp Mơ
quãng tám 1
quãng tám 2
quãng tám 3
Hình 8.4 Quy trình DeepDream: các quy mô xử lý không gian liên tiếp (quãng tám) và tái tạo chi tiết khi nâng cấp
Đối với mỗi tỷ lệ liên tiếp, từ nhỏ nhất đến lớn nhất, bạn chạy tăng dần độ dốc để tối đa hóa
tổn thất mà bạn đã xác định trước đó, ở tỷ lệ đó. Sau mỗi lần chạy tăng dần độ dốc, bạn nâng cấp
hình ảnh kết quả lên 40%.
Để tránh mất nhiều chi tiết hình ảnh sau mỗi lần tăng tỷ lệ liên tiếp (dẫn đến hình ảnh ngày
càng mờ hoặc bị pixel), bạn có thể sử dụng một mẹo đơn giản: sau mỗi lần tăng tỷ lệ, bạn sẽ đưa
lại các chi tiết bị mất vào hình ảnh, đó là có thể bởi vì bạn biết hình ảnh gốc sẽ trông như thế
nào ở tỷ lệ lớn hơn. Cho một hình ảnh có kích thước nhỏ S và một hình ảnh có kích thước lớn hơn
L, bạn có thể tính toán sự khác biệt giữa hình ảnh ban đầu được thay đổi kích thước thành kích
thước L và bản gốc được thay đổi kích thước thành kích thước S—sự khác biệt này định lượng các
chi tiết bị mất khi chuyển từ S sang L.
Liệt kê 8.12 Chạy tăng dần độ dốc trên các tỷ lệ liên tiếp khác nhau
Chơi với các siêu tham số này sẽ cho Kích thước bước tăng dần
phép bạn đạt được các hiệu ứng mới.
Số tỷ lệ để chạy độ dốc tăng dần
Tỷ lệ kích thước giữa các vảy

bước = 0,01
num_octave = 3 quãng Số bước đi lên để chạy ở mỗi
thang đo
tám = 1,4 lần lặp = 20
Nếu tổn thất lớn hơn 10, bạn sẽ làm gián đoạn quá
trình tăng dần độ dốc để tránh các hiện vật xấu xí.
max_loss = 10.
base_image_path = '...' Điền vào đây với đường dẫn đến hình ảnh bạn muốn sử dụng.
img = preprocess_image(base_image_path)
Tải hình ảnh cơ sở vào một mảng Numpy
(hàm được xác định trong danh sách 8.13)

original_shape = img.shape[1:3] inherit_shapes =
[ original_shape] for i in range(1, num_octave): shape =

Chuẩn bị một danh sách các
tuple([int(dim / (octave_scale ** i)) for dim in
bộ dữ liệu hình dạng xác định
original_shape]) Successful_shapes.append (hình dạng) các tỷ lệ khác nhau để chạy
độ dốc đi lên
Đảo ngược danh sách
kế_hình = kế_hình[::-1] các hình để chúng theo

thứ tự tăng dần
original_img = np.copy(img)
shrunk_original_img = resize_img(img, Successful_shapes[0])

Mở rộng
cho hình dạng trong liên tiếp: print('Đang xử lý Thay đổi kích thước
hình mảng Numpy của hình
hình dạng hình ảnh', hình dạng) img = resize_img(img, hình
ảnh trong mơ ảnh thành tỷ lệ nhỏ nhất
dạng) img = gradient_ascent(img,
Tăng tỷ lệ phiên bản

iterations=số lần lặp lại,
Chạy lên dốc,
nhỏ hơn của hình ảnh
thay đổi giấc mơ bước=bước, max_loss=max_loss)
gốc: nó sẽ được pixel hóa.
upscaled_shrunk_ original_img = resize_img(shrink_ original_img, shape) same_size_ original =
resize_img( original_img, shape) Lost_detail = same_size_ original - upscaled_shrunk_ original_img
img += Lost_detail
shrunk_original_img = resize_img( original_img, shape) save_img(img,
fname='dream_at_scale_' + str(shape) + '.png')
save_img(img, fname='final_dream.png')
Reinjects chi tiết bị mất vào giấc mơ

Tính phiên bản chất lượng cao của ảnh
gốc ở kích thước này Sự khác biệt giữa hai là chi tiết bị mất
khi phóng to.
Lưu ý rằng mã này sử dụng các hàm Numpy phụ trợ đơn giản sau đây, tất cả đều hoạt
động như tên gọi của chúng. Họ yêu cầu bạn phải cài đặt SciPy.
Liệt kê 8.13 Các chức năng phụ trợ
nhập scipy từ
keras.tiền xử lý hình ảnh nhập
def resize_img(img, size): img =
np.copy(img) factor = (1,
float(size[0])/img.shape[1], float(size[1])/
img.shape[2], 1)
trả lại scipy.ndimage.zoom(img, các yếu tố, thứ tự=1)
def save_img(img, fname):
pil_img = de process_image(np.copy(img)) scipy.misc.imsave(fname,

Sử dụng chức năng để mở, thay đổi kích
pil_img)
thước và định dạng ảnh thành các
def pre process_image(image_path): tensor mà Inception V3 có thể xử lý
img = image.load_img(image_path) img =
image.img_to_array(img)

giấc mơ sâu 285
img = np.expand_dims(img, axis=0) img =

inception_v3.pre process_input(img) trả về img
def de process_image(x):
Sử dụng chức năng để chuyển đổi
nếu K.image_data_format() == 'channels_first':
một tensor thành một hình ảnh hợp lệ
x = x.reshape((3, x.shape[2], x.shape[3])) x = x.transpose((1,
2, 0))
khác:
x = x.reshape((x.shape[1], x.shape[2], 3))

Hoàn tác quá trình tiền xử
x/= 2.
lý được thực hiện bởi đầu
x += 0,5
vào inception_v3.pre process_
x *= 255.
x = np.clip(x, 0, 255).astype('uint8') trả về x
LƯU Ý Vì mạng Inception V3 ban đầu đã được đào tạo để nhận dạng các khái niệm
trong hình ảnh có kích thước 299 × 299 và do quá trình này liên quan đến việc thu
nhỏ hình ảnh xuống theo một hệ số hợp lý, nên việc triển khai DeepDream tạo ra
kết quả tốt hơn nhiều trên các hình ảnh nằm trong khoảng 300 × 300 và 400 × 400.
Bất kể, bạn có thể chạy cùng một mã trên các hình ảnh có kích thước và tỷ lệ bất
kỳ.
Bắt đầu từ một bức ảnh chụp trên những ngọn đồi nhỏ giữa Vịnh San Francisco và khuôn viên
Google, chúng tôi đã có được DeepDream như trong hình 8.5.
Hình 8.5 Chạy mã DeepDream trên một hình ảnh ví dụ
Chúng tôi thực sự khuyên bạn nên khám phá những gì bạn có thể làm bằng cách điều chỉnh các
lớp bạn sử dụng trong trường hợp mất mát của mình. Các lớp thấp hơn trong mạng chứa các
biểu diễn cục bộ hơn, ít trừu tượng hơn và dẫn đến các mẫu mơ hình trông giống hình học
hơn. Các lớp cao hơn dẫn đến các mẫu hình ảnh dễ nhận biết hơn dựa trên các đối tượng phổ
biến nhất được tìm thấy trong ImageNet, chẳng hạn như mắt chó, lông chim, v.v. Bạn có thể dùng

tạo ngẫu nhiên các tham số trong từ điển layer_contributions để nhanh chóng khám phá nhiều
kết hợp lớp khác nhau. Hình 8.6 cho thấy một loạt các kết quả thu được bằng cách sử dụng các
cấu hình lớp khác nhau, từ hình ảnh một chiếc bánh ngọt tự làm thơm ngon.
Hình 8.6 Thử một loạt cấu hình DeepDream trên một hình ảnh ví dụ
8.2.2 Kết thúc

DeepDream bao gồm chạy ngược lại một convnet để tạo đầu vào dựa trên
trên các biểu diễn được học bởi mạng.
Kết quả tạo ra rất thú vị và có phần giống với các hiện vật thị giác do con người tạo
ra do sự gián đoạn của vỏ não thị giác thông qua ảo giác. Lưu ý rằng quy trình này
không dành riêng cho các mô hình hình ảnh hoặc thậm chí cho các kết nối. Nó có thể được
thực hiện cho lời nói, âm nhạc, v.v.

Chuyển giao phong cách thần kinh 287
8.3 Chuyển kiểu thần kinh Ngoài
DeepDream, một bước phát triển lớn khác trong sửa đổi hình ảnh dựa trên học sâu là chuyển kiểu
thần kinh, được giới thiệu bởi Leon Gatys et al. vào mùa hè năm 2015.5 Thuật toán chuyển kiểu thần
kinh đã trải qua nhiều cải tiến và tạo ra nhiều biến thể kể từ khi được giới thiệu ban đầu và nó
đã được đưa vào nhiều ứng dụng ảnh trên điện thoại thông minh. Để đơn giản, phần này tập trung vào
công thức được mô tả trong bài báo gốc.
Chuyển đổi kiểu thần kinh bao gồm việc áp dụng kiểu của hình ảnh tham chiếu cho hình ảnh mục
tiêu trong khi bảo toàn nội dung của hình ảnh mục tiêu. Hình 8.7 cho thấy một ví dụ.
mục tiêu nội dung phong cách tham khảo hình ảnh kết hợp
Hình 8.7 Ví dụ chuyển kiểu
Trong bối cảnh này, phong cách về cơ bản có nghĩa là kết cấu, màu sắc và các mẫu trực quan trong
hình ảnh, ở các quy mô không gian khác nhau; và nội dung là cấu trúc vĩ mô cấp cao hơn của hình ảnh.
Ví dụ, các nét vẽ tròn màu xanh và vàng được coi là phong cách trong hình 8.7 (sử dụng Starry
Night của Vincent Van Gogh), và các tòa nhà trong bức ảnh Tübingen được coi là nội dung.
Ý tưởng chuyển kiểu, có liên quan chặt chẽ với ý tưởng tạo kết cấu, đã có lịch sử lâu đời
trong cộng đồng xử lý hình ảnh trước khi phát triển kiểu chuyển kiểu thần kinh vào năm 2015. Nhưng
hóa ra, ý tưởng dựa trên học sâu Việc triển khai chuyển giao phong cách mang lại kết quả vô song
so với những gì đã đạt được trước đây với các kỹ thuật thị giác máy tính cổ điển và chúng đã kích
hoạt một thời kỳ phục hưng đáng kinh ngạc trong các ứng dụng sáng tạo của thị giác máy tính.
Khái niệm chính đằng sau việc triển khai chuyển kiểu cũng giống như ý tưởng trọng tâm của tất
cả các thuật toán học sâu: bạn xác định một hàm mất mát để chỉ định những gì bạn muốn đạt được và
bạn giảm thiểu sự mất mát này. Bạn biết những gì bạn muốn đạt được: bảo tồn nội dung của hình ảnh
gốc trong khi áp dụng phong cách của hình ảnh tham chiếu. Nếu chúng ta có thể xác định nội dung và
phong cách một cách toán học, thì một hàm mất mát thích hợp để giảm thiểu sẽ như sau:
mất mát = khoảng cách (kiểu (hình ảnh tham chiếu) - kiểu (hình_ảnh được tạo)) + khoảng cách (nội dung
(hình ảnh gốc) - nội dung (hình ảnh được tạo))
5
Leon A. Gatys, Alexander S. Ecker, và Matthias Bethge, “A Neural Algorithm of Artistic Style,” arXiv (2015),
https://arxiv.org/abs/1508.06576.

Ở đây, khoảng cách là một hàm định mức, chẳng hạn như định mức L2, nội dung là một hàm lấy hình
ảnh và tính toán biểu diễn nội dung của nó và kiểu dáng là một hàm lấy hình ảnh và tính toán
biểu diễn kiểu của nó. Giảm thiểu sự mất mát này làm cho kiểu(hình_ảnh_tạo) gần với
kiểu(hình_ảnh_tham_chiếu) và nội dung(hình_ảnh_tạo) gần với nội dung(hình_ảnh_tạo), do đó đạt
được sự chuyển kiểu như chúng tôi đã xác định.
Một quan sát cơ bản được thực hiện bởi Gatys et al. là các mạng nơ-ron tích chập sâu đưa
ra một cách để xác định một cách toán học các chức năng kiểu dáng và nội dung .
Hãy xem làm thế nào.
8.3.1 Mất nội dung
Như bạn đã biết, kích hoạt từ các lớp trước đó trong mạng chứa thông tin cục bộ về hình ảnh,
trong khi kích hoạt từ các lớp cao hơn chứa thông tin trừu tượng ngày càng toàn cầu . Được xây
dựng theo một cách khác, việc kích hoạt các tầng khác nhau của một hội tụ cung cấp sự phân tách
nội dung của một hình ảnh theo các tỷ lệ không gian khác nhau. Do đó, bạn mong đợi nội dung của
một hình ảnh, mang tính toàn cầu và trừu tượng hơn, sẽ được ghi lại bằng các biểu diễn của các
lớp trên trong một hội tụ.

Do đó, một ứng cử viên tốt cho việc mất nội dung là chuẩn L2 giữa các kích hoạt của lớp
trên trong một convnet được huấn luyện trước, được tính toán trên hình ảnh đích và các kích
hoạt của cùng một lớp được tính toán trên hình ảnh được tạo. Điều này đảm bảo rằng, khi nhìn từ
lớp trên, hình ảnh được tạo sẽ giống với hình ảnh mục tiêu ban đầu. Giả sử rằng những gì mà các
lớp trên của một convnet nhìn thấy thực sự là nội dung của hình ảnh đầu vào của chúng, thì điều
này hoạt động như một cách để bảo toàn nội dung hình ảnh.
8.3.2 Mất phong cách
Mất nội dung chỉ sử dụng một lớp trên, nhưng mất kiểu theo định nghĩa của Gatys et al. sử dụng
nhiều lớp của một convnet: bạn cố gắng ghi lại hình thức của hình ảnh tham chiếu kiểu ở tất cả
các tỷ lệ không gian được convnet trích xuất, không chỉ một tỷ lệ duy nhất.
Đối với sự mất phong cách, Gatys et al. sử dụng ma trận Gram của các kích hoạt của một lớp: sản
phẩm bên trong của các bản đồ đặc trưng của một lớp nhất định. Sản phẩm bên trong này có thể
được hiểu là đại diện cho một bản đồ về mối tương quan giữa các tính năng của lớp. Các mối quan
hệ đặc trưng này nắm bắt các số liệu thống kê về các mẫu của một quy mô không gian cụ thể,
tương ứng theo kinh nghiệm với sự xuất hiện của kết cấu được tìm thấy ở quy mô này.
Do đó, việc mất kiểu nhằm mục đích duy trì các mối tương quan bên trong tương tự trong các
kích hoạt của các lớp khác nhau, trên hình ảnh tham chiếu kiểu và hình ảnh được tạo. Đổi lại,
điều này đảm bảo rằng kết cấu được tìm thấy ở các tỷ lệ không gian khác nhau trông giống nhau
trên hình ảnh tham chiếu kiểu và hình ảnh được tạo.
Nói tóm lại, bạn có thể sử dụng một convnet được đào tạo trước để xác định một tổn thất sẽ
thực hiện những việc sau: Bảo toàn nội dung bằng cách duy trì các kích hoạt lớp cấp cao
tương tự giữa hình ảnh nội dung đích và hình ảnh được tạo. Convnet sẽ “thấy” cả hình ảnh
mục tiêu và hình ảnh được tạo đều chứa những thứ giống nhau.

Duy trì phong cách bằng cách duy trì các mối tương quan tương tự trong quá trình kích hoạt cho
cả lớp cấp thấp và lớp cấp cao. Tương quan tính năng nắm bắt kết cấu: hình ảnh được tạo và
hình ảnh tham chiếu kiểu phải chia sẻ cùng kết cấu ở các tỷ lệ không gian khác nhau.
Bây giờ, hãy xem triển khai Keras của thuật toán chuyển kiểu thần kinh gốc năm 2015. Như bạn sẽ thấy,
nó có nhiều điểm tương đồng với việc triển khai DeepDream được phát triển trong phần trước.
8.3.3 Chuyển kiểu thần kinh trong Keras
Chuyển đổi kiểu thần kinh có thể được thực hiện bằng cách sử dụng bất kỳ convnet được đào tạo trước
nào. Tại đây, bạn sẽ sử dụng mạng VGG19 được sử dụng bởi Gatys et al. VGG19 là một biến thể đơn giản
của công việc mạng VGG16 được giới thiệu trong chương 5, với ba lớp chập hơn.
Đây là quy trình chung:
1 Thiết lập mạng tính toán kích hoạt lớp VGG19 cho hình ảnh tham chiếu kiểu, hình ảnh mục tiêu và
hình ảnh được tạo cùng một lúc.
2. Sử dụng kích hoạt lớp được tính toán trên ba hình ảnh này để xác định hàm mất mát được mô tả
trước đó, mà bạn sẽ giảm thiểu để đạt được sự chuyển đổi kiểu dáng.
3 Thiết lập quy trình giảm dần độ dốc để giảm thiểu chức năng mất mát này.
Hãy bắt đầu bằng cách xác định đường dẫn đến hình ảnh tham chiếu kiểu và hình ảnh đích. Để đảm bảo
rằng các hình ảnh được xử lý có kích thước tương tự nhau (các kích thước quá khác nhau khiến việc
chuyển kiểu khó khăn hơn), sau đó, bạn sẽ thay đổi kích thước tất cả chúng thành chiều cao chung là 400 px.
Liệt kê 8.14 Định nghĩa các biến ban đầu
từ keras.preprocessing.image nhập load_img, img_to_array

Đường dẫn đến hình ảnh
bạn muốn chuyển đổi
target_image_path = 'img/portrait.jpg'
style_reference_image_path = 'img/transfer_style_reference.jpg'
Đường dẫn đến
hình ảnh phong cách

chiều rộng, chiều cao = load_img(đường dẫn_hình_ảnh_đích).size img_height
Kích thước của
= 400 img_width = int(chiều rộng * img_height / chiều cao)
hình ảnh được tạo
Bạn cần một số chức năng phụ trợ để tải, tiền xử lý và hậu xử lý hình ảnh vào và ra khỏi hội nghị
VGG19 .
Liệt kê 8.15 Các chức năng phụ trợ
nhập numpy dưới dạng np từ

keras.application nhập vgg19
def pre process_image(image_path):

img = load_img(image_path, target_size=(img_height, img_width)) img = img_to_array(img) img =
np.expand_dims(img, axis=0) img = vgg19.pre process_input(img) return img

def de process_image(x):
x[:, :, 0] += 103,939
Căn giữa không bằng cách xóa giá trị pixel trung bình khỏi
x[:, :, 1] += 116,779 ImageNet. Thao tác này đảo ngược quá trình chuyển đổi được
x[:, :, 2] += 123,68 thực hiện bởi vgg19.pre process_input.
x = x[:, :, ::-1] x =
np.clip(x, 0, 255).astype('uint8') Chuyển đổi hình ảnh từ 'BGR' thành 'RGB'.

trả lại x Đây cũng là một phần của quá trình đảo
ngược vgg19.pre process_input.
Hãy thiết lập mạng VGG19 . Nó lấy một loạt ba hình ảnh làm đầu vào: hình ảnh tham chiếu kiểu,
hình ảnh đích và một trình giữ chỗ sẽ chứa hình ảnh được tạo. Trình giữ chỗ là một tenxơ tượng
trưng, các giá trị của chúng được cung cấp bên ngoài thông qua các mảng Numpy. Tham chiếu kiểu
và hình ảnh đích là tĩnh và do đó được xác định bằng K.constant, trong khi các giá trị chứa
trong trình giữ chỗ của hình ảnh được tạo sẽ thay đổi theo thời gian.
Liệt kê 8.16 Đang tải mạng VGG19 đã được huấn luyện trước và áp dụng nó vào ba hình ảnh
Trình giữ chỗ sẽ chứa hình ảnh
từ máy ảnh nhập phụ trợ dưới dạng K được tạo
target_image = K.constant(pre process_image( target_image_path)) style_reference_image =

K.constant(pre process_image(style_reference_image_path))combination_image = K.placeholder((1, img_height, img_width,
3))
input_tensor = K.concatenate([ target_image,

Kết hợp ba hình ảnh
style_reference_image,
trong một đợt duy nhất
combin_image], axis=0)
model = vgg19.VGG19(input_tensor=input_tensor, weights='imagenet', Xây dựng mạng VGG19 với lô ba hình

include_top=False) ảnh làm đầu vào. Mô hình sẽ được
tải với các trọng số ImageNet được
print('Đã tải mô hình.') đào tạo trước.
Hãy xác định mất mát nội dung, điều này sẽ đảm bảo lớp trên cùng của hội nghị VGG19 có chế độ
xem tương tự giữa hình ảnh mục tiêu và hình ảnh được tạo.
Liệt kê 8.17 Mất nội dung
def content_loss(cơ sở, kết hợp): return

K.sum(K.square(kết hợp - cơ sở))
Tiếp theo là mất phong cách. Nó sử dụng một chức năng phụ trợ để tính toán ma trận Gram của ma
trận đầu vào: bản đồ các mối tương quan được tìm thấy trong ma trận đặc trưng ban đầu.
Liệt kê 8.18 Mất phong cách
def gram_matrix(x): features

= K.batch_flatten(K.permute_dimensions(x, (2, 0, 1))) gram = K.dot(features,
K.transpose(features)) return gram

def style_loss(kiểu, kết hợp): S = gram_matrix(kiểu)
C = gram_matrix(kết hợp) kênh = 3 kích thước

= img_height * img_width trả về
K.sum(K.square(S - C)) / (4. * (kênh ** 2) *
(kích thước ** 2))
Đối với hai thành phần mất mát này, bạn thêm một thành phần thứ ba: tổng biến thể mất mát, hoạt
động trên các pixel của hình ảnh kết hợp được tạo. Nó khuyến khích sự liên tục về không gian
trong hình ảnh được tạo, do đó tránh được kết quả quá nhiều pixel. Bạn có thể giải thích nó như
là một sự mất mát chính quy.
Liệt kê 8.19 Tổng tổn thất biến đổi
def total_variation_loss(x): a = K.square(
x[:, :img_height - 1, :img_width - 1, :] - x[:, 1:, :img_width -
1, :])
b = K.square(
x[:, :img_height - 1, :img_width - 1, :] - x[:, :img_height - 1,
1:, :])
trả về K.sum(K.pow(a + b, 1.25))
Khoản lỗ mà bạn giảm thiểu là trung bình cộng của ba khoản lỗ này. Để tính toán tổn thất nội
dung, bạn chỉ sử dụng một lớp trên—lớp block5_conv2 —trong khi đối với tổn thất kiểu, bạn sử dụng
danh sách các lớp hơn là kéo dài cả lớp cấp thấp và cấp cao. Bạn thêm tổng tổn thất biến thể vào
cuối.
Tùy thuộc vào hình ảnh tham chiếu kiểu và hình ảnh nội dung bạn đang sử dụng, có thể bạn sẽ
muốn điều chỉnh hệ số content_weight (phần đóng góp của việc mất mát nội dung vào tổng lượng mất
mát). Content_weight cao hơn có nghĩa là nội dung mục tiêu sẽ dễ nhận biết hơn trong hình ảnh
được tạo.
Liệt kê 8.20 Xác định tổn thất cuối cùng mà bạn sẽ giảm thiểu
Từ điển ánh xạ tên lớp tới

tenxơ kích hoạt
đầu ra_dict = dict([(layer.name, layer.output) cho lớp trong model.layers])
content_layer = 'block5_conv2'
style_layers = ['block1_conv1', Lớp được sử dụng để mất nội dung
'khối2_conv1',
'khối3_conv1', Các lớp được sử dụng để mất kiểu
'khối4_conv1',
'block5_conv1']
tổng_biến_trọng = 1e-4
Trọng số trong bình quân gia quyền của
style_weight=1.
các thành phần tổn thất
nội dung_trọng lượng = 0,025

loss = K.variable(0.) layer_features

Thêm Bạn sẽ xác định tổn thất bằng
= outputs_dict[content_layer] target_image_features =
mất cách thêm tất cả các thành
layer_features[0, :, :, :] tổ hợp_features = layer_features[2, :, :, :] loss += phần vào biến vô hướng này.
nội dung
content_weight * content_loss(target_image_features,
tổ hợp_tính năng)
cho layer_name trong style_layers:

Thêm một thành
layer_features = outputs_dict[layer_name] style_reference_features
phần mất kiểu
= layer_features[1, :, :, :] tổ hợp_features = layer_features[2, :, :, :] sl =
cho mỗi lớp mục tiêu
style_loss(style_reference_features, tổ hợp_features) loss += (style_weight /
Thêm tổng
len(style_layers)) * sl
tổn
thất biến
thể
tổn thất += tổng_trọng số_biến_đổi * tổng_tổn_lượng_biến_đổi(hình_ảnh_kết_hợp)
Cuối cùng, bạn sẽ thiết lập quy trình giảm độ dốc. Trong bản gốc Gatys et al. giấy, tối ưu hóa được
thực hiện bằng cách sử dụng thuật toán L-BFGS , vì vậy đó là những gì bạn sẽ sử dụng ở đây.
Đây là điểm khác biệt chính so với ví dụ DeepDream trong phần 8.2. Thuật toán L-BFGS đi kèm với
SciPy, nhưng có hai hạn chế nhỏ với việc triển khai SciPy: Nó yêu cầu bạn chuyển giá trị của hàm
mất mát và giá trị của gra
dients như hai chức năng riêng biệt.
Nó chỉ có thể được áp dụng cho các vectơ phẳng, trong khi bạn có một mảng hình ảnh 3D.
Sẽ không hiệu quả nếu tính toán giá trị của hàm mất mát và giá trị của gradient một cách độc lập,
bởi vì làm như vậy sẽ dẫn đến rất nhiều tính toán dư thừa giữa hai giá trị này; quá trình này sẽ
chậm gần gấp đôi so với việc tính toán chúng cùng nhau. Để bỏ qua điều này, bạn sẽ thiết lập một lớp
Python có tên là Evaluator để tính toán cả giá trị mất mát và giá trị độ dốc cùng một lúc, trả về
giá trị mất mát khi được gọi lần đầu tiên và lưu trữ độ dốc cho lần gọi tiếp theo.
Liệt kê 8.21 Thiết lập quy trình giảm dần độ dốc
grads = K.gradients(loss, combi_image)[0]

Nhận độ
dốc của fetch_loss_and_grads = K.function([tổ hợp_hình ảnh], [tổn thất, điểm])

hình
Chức năng tìm
ảnh được
Người đánh giá lớp (đối tượng): nạp các giá
tạo liên
trị của tổn thất
quan đến
def __init__(self): hiện tại và độ
sự mất mát
self.loss_value = Không
dốc hiện tại
self.grads_values = Không
def loss(self, x): khẳng định
self.loss_value là Không x = x.reshape((1,
img_height, img_width, 3)) outs = fetch_loss_and_grads([x])
Lớp này bao hàm fetch_loss_and_grads theo

cách cho phép bạn truy xuất các tổn thất và độ dốc
thông qua hai lệnh gọi phương thức riêng biệt, được yêu
cầu bởi trình tối ưu hóa SciPy mà bạn sẽ sử dụng.

loss_value = outs[0] grad_values
= outs[1].flatten().astype('float64') self.loss_value = loss_value
self.grad_values = grad_values return self.loss_value
def grads(bản thân, x):
khẳng định self.loss_value không phải là Không có
grad_values = np.copy(self.grad_values) self.loss_value = Không
có self.grad_values = Không có return grad_values
người đánh giá = Người đánh giá()
Cuối cùng, bạn có thể chạy quy trình tăng dần độ dốc bằng cách sử dụng thuật toán L-BFGS
của SciPy , lưu hình ảnh được tạo hiện tại ở mỗi lần lặp lại thuật toán (ở đây, một lần
lặp lại đại diện cho 20 bước tăng dần độ dốc).
Liệt kê 8.22 Vòng lặp chuyển kiểu
từ scipy.optimize nhập fmin_l_bfgs_b từ nhập scipy.misc tiết kiệm

Đây là trạng thái ban
thời gian nhập
đầu: hình ảnh mục tiêu.
Bạn làm phẳng hình ảnh vì

result_prefix = 'my_result' lần lặp = 20
scipy.optimize.fmin_l_bfgs_b chỉ
có thể xử lý các vectơ phẳng.
x = pre process_image(target_image_path) x = x.flatten() for i

in range(lặp lại): print('Bắt đầu lặp lại', i) start_time = Chạy tối ưu hóa L-BFGS trên
time.time() x, min_val, info = fmin_l_bfgs_b(evaluator.loss, các pixel của hình ảnh được
tạo để giảm thiểu mất kiểu
thần kinh. Lưu ý rằng bạn
phải truyền hàm tính toán
x,
tổn thất và hàm tính toán độ
dốc dưới dạng hai đối số
fprime=evaluator.grads, maxfun=20)
riêng biệt.
print('Giá trị mất mát hiện tại:', min_val) img =
x.copy().reshape((img_height, img_width, 3)) img = de process_image(img) fname =
result_prefix + '_at_iteration_%d.png' % i imsave( fname, img) print('Hình ảnh
được lưu dưới dạng', fname) end_time = time.time() print('Lặp lại %d hoàn thành Lưu hiện tại
trong %ds' % (i, end_time - start_time)) hình ảnh được tạo ra.
Hình 8.8 cho thấy những gì bạn nhận được. Hãy nhớ rằng những gì kỹ thuật này đạt được chỉ
là một hình thức tạo lại kết cấu hình ảnh hoặc chuyển kết cấu. Nó hoạt động tốt nhất với
các hình ảnh tham chiếu kiểu có kết cấu mạnh mẽ và có tính tự tương tự cao cũng như với
các mục tiêu nội dung không yêu cầu mức độ chi tiết cao để dễ nhận biết. Nó thường không
thể đạt được những kỳ tích khá trừu tượng như chuyển phong cách của bức chân dung này sang
bức chân dung khác. Thuật toán gần với xử lý tín hiệu cổ điển hơn là AI, vì vậy đừng mong
đợi nó hoạt động như một phép màu!

Hình 8.8 Một số kết quả ví dụ

Ngoài ra, hãy lưu ý rằng việc chạy thuật toán chuyển kiểu này chậm. Tuy nhiên, quá trình chuyển
đổi do thiết lập vận hành đủ đơn giản để có thể học được nó bằng một mạng kết nối tiếp liệu nhỏ,
nhanh—miễn là bạn có sẵn dữ liệu đào tạo phù hợp.
Do đó, có thể đạt được chuyển đổi kiểu nhanh bằng cách trước tiên dành nhiều chu kỳ tính toán để
tạo các ví dụ đào tạo đầu vào-đầu ra cho một hình ảnh tham chiếu kiểu cố định, sử dụng phương pháp
được nêu ở đây, sau đó đào tạo một convnet đơn giản để tìm hiểu chuyển đổi theo kiểu cụ thể này.
Khi đã xong, việc tạo kiểu cho một hình ảnh nhất định là ngay lập tức: nó chỉ là một bước chuyển
tiếp của convnet nhỏ này.
8.3.4 Kết thúc

Chuyển kiểu bao gồm việc tạo một hình ảnh mới giữ nguyên nội dung của một
ảnh mục tiêu đồng thời ghi lại phong cách của ảnh tham chiếu. Nội dung
có thể được nắm bắt bằng cách kích hoạt cấp cao của một convnet. Phong cách
có thể được nắm bắt bởi các mối tương quan bên trong của việc kích hoạt các lớp khác nhau của
một convnet. Do đó, học sâu cho phép chuyển giao phong cách được hình thành như một sự
tối ưu hóa
quá trình sử dụng một mất mát được xác định với một convnet
được đào tạo trước. Bắt đầu từ ý tưởng cơ bản này, có thể có nhiều biến thể và cải tiến.

8.4 Tạo hình ảnh với bộ mã hóa tự động đa dạng

Lấy mẫu từ một không gian hình ảnh tiềm ẩn để tạo ra những hình ảnh hoàn toàn mới hoặc chỉnh
sửa những hình ảnh hiện có hiện là ứng dụng phổ biến và thành công nhất của trí tuệ nhân tạo
sáng tạo. Trong phần này và phần tiếp theo, chúng ta sẽ xem xét một số khái niệm cấp cao liên
quan đến tạo hình ảnh, cùng với các chi tiết triển khai liên quan đến hai kỹ thuật chính trong
lĩnh vực này: bộ mã hóa tự động biến đổi (VAE) và mạng đối nghịch chung (GAN). Các kỹ thuật
chúng tôi trình bày ở đây không dành riêng cho hình ảnh—bạn có thể phát triển các không gian
âm thanh, âm nhạc hoặc thậm chí văn bản tiềm ẩn bằng cách sử dụng GAN và VAE—nhưng trong thực
tế, các kết quả thú vị nhất thu được với hình ảnh và đó là những gì chúng tôi tập trung vào đây.
8.4.1 Lấy mẫu từ các không gian tiềm ẩn của hình ảnh
Ý tưởng chính của việc tạo hình ảnh là phát triển một không gian tiềm ẩn chiều thấp của các
biểu diễn (mà tự nhiên là một không gian vectơ) trong đó bất kỳ điểm nào cũng có thể được ánh
xạ tới một hình ảnh trông giống như thật. Mô-đun có khả năng thực hiện ánh xạ này, lấy đầu vào
là điểm tiềm ẩn và xuất hình ảnh (một lưới pixel), được gọi là bộ tạo (trong trường hợp GAN)
hoặc bộ giải mã (trong trường hợp VAE). Khi một không gian tiềm ẩn như vậy đã được phát triển,
bạn có thể lấy mẫu các điểm từ nó, một cách cố ý hoặc ngẫu nhiên, và bằng cách ánh xạ chúng
vào không gian ảnh, tạo ra những ảnh chưa từng thấy trước đây (xem hình 8.9).
Dữ liệu đào tạo
Quá trình
?
học tập
Máy phát/Bộ giải mã
Vectơ từ không Hình ảnh
gian tiềm ẩn nhân tạo

Không gian tiềm
ẩn của hình
ảnh (không gian vectơ)
Hình 8.9 Học một không gian vectơ tiềm ẩn của ảnh và sử dụng nó để lấy mẫu ảnh mới
GAN và VAE là hai chiến lược khác nhau để tìm hiểu các không gian biểu diễn hình ảnh
tiềm ẩn như vậy, mỗi chiến lược có các đặc điểm riêng. VAE rất tốt cho việc tìm hiểu
các không gian tiềm ẩn có cấu trúc tốt, trong đó các hướng cụ thể mã hóa một trục biến
thể có ý nghĩa trong dữ liệu. GAN tạo ra hình ảnh có khả năng mang tính thực tế cao,
nhưng không gian tiềm ẩn mà chúng đến từ đó có thể không có nhiều cấu trúc và tính liên tục.

Tạo hình ảnh với bộ mã hóa tự động đa dạng 297
Hình 8.10 Một không gian liên tục của các mặt do Tom White tạo ra bằng VAE
8.4.2 Vectơ khái niệm để chỉnh sửa hình ảnh
Chúng ta đã gợi ý về ý tưởng véc-tơ khái niệm khi đề cập đến thuật ngữ nhúng trong
chương 6. Ý tưởng này vẫn giống nhau: cho một không gian tiềm ẩn của các biểu diễn hoặc
không gian nhúng, một số hướng nhất định trong không gian có thể mã hóa các trục biến
thiên thú vị. trong dữ liệu ban đầu. Ví dụ, trong một không gian tiềm ẩn của hình ảnh
các khuôn mặt, có thể có một vectơ nụ cười s, sao cho nếu điểm tiềm ẩn z là biểu diễn
nhúng của một khuôn mặt nhất định, thì điểm tiềm ẩn z + s là biểu diễn nhúng của cùng
một khuôn mặt , mỉm cười. Khi bạn đã xác định được một vectơ như vậy, thì có thể chỉnh
sửa hình ảnh bằng cách chiếu chúng vào không gian tiềm ẩn, di chuyển biểu diễn của chúng
theo cách có ý nghĩa, sau đó giải mã chúng trở lại không gian hình ảnh. Về cơ bản, có
các vectơ khái niệm cho bất kỳ chiều biến thiên độc lập nào trong không gian hình ảnh—
trong trường hợp khuôn mặt, bạn có thể khám phá các vectơ để thêm kính râm vào khuôn
mặt, bỏ kính, biến khuôn mặt nam thành khuôn mặt nữ, v.v. Hình 8.11 là một ví dụ về
vectơ nụ cười, một vectơ khái niệm được phát hiện bởi Tom White từ Trường Thiết kế Đại
học Victoria ở New Zealand, sử dụng VAE được đào tạo trên bộ dữ liệu khuôn mặt của những
người nổi tiếng (bộ dữ liệu CelebA).

Hình 8.11 Vectơ nụ cười
8.4.3 Bộ mã hóa tự động đa dạng
Các bộ mã hóa tự động đa dạng, được Kingma và Welling đồng thời phát hiện vào tháng 12
năm 20136 và Rezende, Mohamed và Wierstra vào tháng 1 năm 2014,7 là một loại mô hình
tổng quát đặc biệt thích hợp cho nhiệm vụ chỉnh sửa hình ảnh thông qua các vectơ khái
niệm. Chúng là một giải pháp hiện đại sử dụng bộ mã hóa tự động—một loại mạng nhằm mục
đích mã hóa đầu vào thành không gian tiềm ẩn có chiều thấp và sau đó giải mã lại—kết hợp
các ý tưởng từ học sâu với suy luận Bayes.
Một bộ mã hóa hình ảnh cổ điển lấy một hình ảnh, ánh xạ nó tới một không gian vectơ
tiềm ẩn thông qua một mô-đun bộ mã hóa, sau đó giải mã nó trở lại đầu ra có cùng kích
thước với hình ảnh gốc, thông qua một mô-đun bộ giải mã (xem hình 8.12). Sau đó, nó được
đào tạo bằng cách sử dụng hình ảnh giống như dữ liệu đích làm hình ảnh đầu vào, nghĩa là
bộ mã hóa tự động học cách tái tạo lại đầu vào ban đầu. Bằng cách áp đặt các ràng buộc
khác nhau lên mã (đầu ra của bộ mã hóa), bạn có thể khiến bộ mã hóa tự động tìm hiểu ít
nhiều các biểu diễn tiềm ẩn thú vị thú vị của dữ liệu. Thông thường nhất, bạn sẽ hạn chế
mã có ít chiều và thưa thớt (hầu hết là số không), trong trường hợp đó, bộ mã hóa hoạt
động như một cách để nén dữ liệu đầu vào thành ít bit thông tin hơn.
6
Diederik P. Kingma và Max Welling, “Variational Bayes tự động mã hóa, arXiv (2013), https://arxiv.org/
abs/1312.6114.
7
Danilo Jimenez Rezende, Shakir Mohamed và Daan Wierstra, “Truyền ngược ngẫu nhiên và suy luận gần đúng
đối tác trong các mô hình tạo sâu,” arXiv (2014), https://arxiv.org/abs/1401.4082.

Mã hoá bộ giải mã
Đầu vào đại diện Đầu vào được xây
ban đầu x nén dựng lại x
Hình 8.12 Bộ mã hóa tự động: ánh xạ đầu vào x thành biểu diễn được nén và sau đó giải mã lại
thành x'
Trong thực tế, các bộ mã hóa tự động cổ điển như vậy không dẫn đến các không gian
tiềm ẩn có cấu trúc đặc biệt hữu ích hoặc độc đáo. Chúng cũng không giỏi nén lắm. Vì
những lý do này, chúng phần lớn đã lỗi thời. Tuy nhiên, các VAE tăng cường bộ mã hóa
tự động bằng một chút ma thuật thống kê buộc chúng phải tìm hiểu các không gian tiềm
ẩn có cấu trúc cao, liên tục. Chúng đã trở thành một công cụ mạnh mẽ để tạo ra hình ảnh.
Một VAE, thay vì nén hình ảnh đầu vào của nó thành một mã cố định trong không gian
tiềm ẩn, biến hình ảnh thành các tham số của phân phối thống kê: giá trị trung bình
và phương sai. Về cơ bản, điều này có nghĩa là bạn đang giả định rằng hình ảnh đầu
vào đã được tạo bởi một quy trình thống kê và tính ngẫu nhiên của quy trình này sẽ
được tính đến trong quá trình mã hóa và giải mã. Sau đó, VAE sử dụng các tham số
trung bình và phương sai để lấy mẫu ngẫu nhiên một phần tử của phân phối và giải mã
phần tử đó trở lại đầu vào ban đầu (xem hình 8.13). Tính ngẫu nhiên của quá trình này
cải thiện độ bền và buộc không gian tiềm ẩn mã hóa các biểu diễn có ý nghĩa ở mọi
nơi: mọi điểm được lấy mẫu trong không gian tiềm ẩn đều được giải mã thành đầu ra hợp lệ.
Phân phối trên không gian
tiềm ẩn được xác định bởi

hình ảnh đầu vào z_mean và z_log_var
Mã hoá
Hình ảnh được xây
dựng lại
bộ giải mã
Điểm lấy mẫu ngẫu

nhiên từ phân
phối
Hình 8.13 Một VAE ánh xạ một hình ảnh tới hai vectơ, z_mean và z_log_sigma, xác định phân bố xác suất
trên không gian tiềm ẩn, được sử dụng để lấy mẫu điểm tiềm ẩn để giải mã.

Về mặt kỹ thuật, đây là cách VAE hoạt động:
1 Mô-đun bộ mã hóa biến các mẫu đầu vào input_img thành hai tham số trong
một không gian tiềm ẩn của các biểu diễn, z_mean và z_log_variance.
2 Bạn lấy mẫu ngẫu nhiên một điểm z từ phân phối chuẩn tiềm ẩn được giả định để tạo ra
hình ảnh đầu vào, thông qua z = z_mean + exp(z_log_variance) * epsilon, trong đó
epsilon là một tenxơ ngẫu nhiên của các giá trị nhỏ.
3 Mô-đun bộ giải mã ánh xạ điểm này trong không gian tiềm ẩn trở lại đầu vào ban đầu
hình ảnh.
Vì epsilon là ngẫu nhiên nên quy trình đảm bảo rằng mọi điểm gần với vị trí tiềm ẩn mà bạn đã mã
hóa input_img (z-mean) đều có thể được giải mã thành thứ gì đó tương tự như input_img, do đó buộc
không gian tiềm ẩn phải liên tục có ý nghĩa. Bất kỳ hai điểm gần nhau nào trong không gian tiềm
ẩn sẽ giải mã thành các hình ảnh rất giống nhau. Tính liên tục, kết hợp với số chiều thấp của
không gian tiềm ẩn, buộc mọi hướng trong không gian tiềm ẩn mã hóa một trục biến thiên có ý nghĩa
trung bình của dữ liệu, làm cho không gian tiềm ẩn có cấu trúc rất chặt chẽ và do đó rất phù hợp
để có thể thao tác thông qua các vectơ khái niệm.
Các tham số của VAE được đào tạo thông qua hai hàm mất mát: mất mát tái tạo buộc các mẫu
được giải mã khớp với đầu vào ban đầu và mất mát chính quy giúp tìm hiểu các không gian tiềm
ẩn được định dạng tốt và giảm tình trạng thừa dữ liệu đào tạo. Hãy nhanh chóng xem qua việc
triển khai Keras của VAE. Về mặt sơ đồ, nó trông như thế này:
z_mean, z_log_variance = bộ mã hóa(input_img)

Mã hóa đầu vào thành tham
z = z_mean + exp(z_log_variance) * epsilon số trung bình và phương sai
được xây dựng lại_img = bộ giải mã (z) Vẽ một điểm tiềm ẩn bằng cách sử
Giải mã
dụng một epsilon ngẫu nhiên nhỏ
z trở lại
mô hình = Mô hình (input_img, được xây dựng lại_img)
một tấm ảnh Khởi tạo mô hình bộ mã hóa tự
động, mô hình này ánh xạ một hình ảnh

đầu vào để tái tạo lại nó
Sau đó, bạn có thể đào tạo mô hình bằng cách sử dụng tổn thất tái tạo và tổn thất chính quy.
Danh sách sau đây hiển thị mạng bộ mã hóa mà bạn sẽ sử dụng, ánh xạ hình ảnh tới các tham
số của phân phối xác suất trên không gian tiềm ẩn. Đó là một convnet đơn giản ánh xạ hình ảnh
đầu vào x thành hai vectơ, z_mean và z_log_var.
Liệt kê 8.23 Mạng bộ mã hóa VAE

máy ảnh nhập lớp từ máy ảnh
nhập phụ trợ dưới dạng K từ máy
ảnh.models Nhập mô hình numpy dưới dạng
np
img_shape = (28, 28, 1)

batch_size = 16 latent_dim = 2 Kích thước của không
gian tiềm ẩn: một mặt phẳng 2D
input_img = keras.Input(shape=img_shape)

x = Layers.Conv2D(32, 3,
padding='same', activation='relu')(input_img) x = Layers.Conv2D(64, 3,
padding='same', activation='relu', sải chân=( 2, 2))(x) x = layer.Conv2D(64, 3, padding='same',
activation='relu')(x) x = layer.Conv2D(64, 3, padding='same',
activation ='relu')(x)
shape_before_flattening = K.int_shape(x)
x = layer.Flatten()(x) x =
layer.Dense(32, activation='relu')(x)
Hình ảnh đầu vào cuối

z_mean = layer.Dense(latent_dim)(x) z_log_var =
cùng được mã hóa thành
layer.Dense(latent_dim)(x)
hai tham số này.
Tiếp theo là mã để sử dụng z_mean và z_log_var, các tham số của phân bổ thống kê được giả định
là đã tạo ra input_img, để tạo ra một điểm không gian tiềm ẩn z.
Tại đây, bạn bọc một số mã tùy ý (được xây dựng dựa trên các nguyên hàm phụ trợ của Keras) vào
một lớp Lambda . Trong Keras, mọi thứ cần phải là một lớp, do đó, mã không phải là một phần của
lớp tích hợp phải được bao bọc trong Lambda (hoặc trong một lớp tùy chỉnh).
Liệt kê 8.24 Hàm lấy mẫu không gian tiềm ẩn
lấy mẫu def (args):

z_mean, z_log_var = args epsilon =
K.random_normal(shape=(K.shape(z_mean)[0],latent_dim),
nghĩa là = 0., stddev = 1.)
trả về z_mean + K.exp(z_log_var) * epsilon
z = các lớp.Lambda(lấy mẫu)([z_mean, z_log_var])
Danh sách sau đây cho thấy việc triển khai bộ giải mã. Bạn định hình lại vectơ z theo kích thước
của hình ảnh và sau đó sử dụng một vài lớp tích chập để thu được đầu ra hình ảnh cuối cùng có
cùng kích thước với đầu vào_img ban đầu.
Liệt kê 8.25 Mạng bộ giải mã VAE, ánh xạ các điểm không gian tiềm ẩn thành hình ảnh
decoder_input = layer.Input(K.int_shape(z)[1:]) Nhập nơi bạn sẽ cung cấp z
x = layer.Dense(np.prod(shape_before_flattening[1:]),
Lấy mẫu đầu vào
activation='relu')(decoder_input)
x = layer.Reshape(shape_before_flattening[1:])(x)
x = layer.Conv2DTranspose(32, 3,
đệm = 'giống', kích
Sử dụng lớp Conv2DTranspose
hoạt = 'relu', sải chân =
và lớp Conv2D để giải mã z
(2, 2)) (x) thành bản đồ đối tượng có
x = layer.Conv2D(1, 3, cùng kích thước với đầu vào
padding='same', hình ảnh gốc
activation='sigmoid')(x)
Định hình lại z thành một bản đồ đặc trưng có cùng hình dạng với bản đồ
đặc trưng ngay trước lớp Làm phẳng cuối cùng trong mô hình bộ mã hóa

bộ giải mã = Model(decoder_input, x)
Khởi tạo mô hình bộ giải mã, biến
“decoder_input” thành hình ảnh
z_decoded = bộ giải mã(z)
được giải mã
Áp dụng nó cho z
để khôi phục z đã giải mã
Mất kép của VAE không phù hợp với kỳ vọng truyền thống về chức năng mẫu thông minh của mất biểu
mẫu (đầu vào, mục tiêu). Do đó, bạn sẽ thiết lập tổn thất bằng cách viết một lớp tùy chỉnh sử
dụng bên trong phương thức lớp add_loss tích hợp để tạo tổn thất tùy ý.
Liệt kê 8.26 Lớp tùy chỉnh được sử dụng để tính tổn thất VAE
lớp CustomVariationalLayer(keras.layers.Layer):
def vae_loss(self, x, z_decoded):

x = K.phẳng(x)
z_decoded = K.flatten(z_decoded) xent_loss =

keras.metrics.binary_crossentropy(x, z_decoded) kl_loss = -5e-4 * K.mean( 1 + z_log_var -
K.square(z_mean) - K.exp(z_log_var), trục =-1)
trả về K.mean(xent_loss + kl_loss)
cuộc gọi def(self, đầu vào): x =

Bạn triển khai các lớp tùy chỉnh
Bạn không sử đầu vào[0] z_decoded = đầu
bằng cách viết một phương thức gọi.
dụng đầu ra vào[1] loss = self.vae_loss(x,
này, nhưng z_decoded) self.add_loss(mất, đầu vào=đầu vào) trả
lớp phải trả Gọi lớp tùy chỉnh trên đầu
về x
lại một cái gì đó. vào và đầu ra đã giải mã để
có được đầu ra mô hình cuối
y = CustomVariationalLayer()([input_img, z_decoded]) cùng
Cuối cùng, bạn đã sẵn sàng khởi tạo và huấn luyện mô hình. Bởi vì tổn thất được xử lý trong lớp
tùy chỉnh, nên bạn không chỉ định tổn thất bên ngoài tại thời điểm biên dịch (loss=None), điều
này có nghĩa là bạn sẽ không chuyển dữ liệu đích trong quá trình đào tạo (như bạn có thể thấy,
bạn chỉ chuyển x_train cho mô hình phù hợp).
Liệt kê 8.27 Huấn luyện VAE
từ keras.datasets nhập mnist
vae = Model(input_img, y)
vae.compile(optimizer='rmsprop', loss=None) vae.summary()
(x_train, _), (x_test, y_test) = mnist.load_data()
x_train = x_train.astype('float32') / 255. x_train =

x_train.reshape(x_train.shape + (1,)) x_test = x_test.astype('float32') /
255. x_test = x_test.reshape(x_test.shape + (1,))
vae.fit(x=x_train, y=None,
xáo trộn = Đúng,
epochs=10,
batch_size=batch_size,
validation_data=(x_test, Không có))

Sau khi một mô hình như vậy được huấn luyện—trong trường hợp này là trên MNIST —bạn có thể sử dụng công việc của
mạng bộ giải mã để biến các vectơ không gian tiềm ẩn tùy ý thành hình ảnh.
Liệt kê 8.28 Lấy mẫu một lưới các điểm từ không gian tiềm ẩn 2D và giải mã chúng thành hình ảnh
nhập matplotlib.pyplot dưới dạng plt từ định
mức nhập scipy.stats

Bạn sẽ hiển thị một lưới gồm 15 × 15
n = 15 chữ số (tổng cộng 255 chữ số).
Digit_size = 28 figure Biến đổi tọa độ cách đều

= np.zeros((digit_size * Grid_x = n, chữ số_size * n)) tuyến tính bằng cách sử dụng hàm
Norm.ppf(np.linspace(0.05, 0.95, n)) Grid_y = Norm.ppf(np.linspace(0.05, SciPy ppf để tạo ra các giá trị
của biến tiềm ẩn z (vì giá trị trước
0.95, n))
của không gian tiềm ẩn là Gaussian)
cho i, yi trong liệt kê (grid_x):
Lặp lại z nhiều lần để tạo
cho j, xi trong liệt kê (grid_y):
thành một lô hoàn chỉnh
z_sample = np.array([[xi, yi]]) z_sample =
np.tile(z_sample, batch_size).reshape(batch_size, 2) x_decoded = decoder.predict(z_sample,
batch_size=batch_size) digit = x_decoded[0]. reshape(digit_size, Digit_size) hình[i * Digit_size:
(i + 1) * Digit_size,
j * Digit_size: (j + 1) * Digit_size] = chữ số
plt.figure(figsize=(10, 10)) Định hình lại chữ số đầu

plt.imshow(figure, cmap='Greys_r') plt.show() tiên trong lô từ 28 × 28 × 1
thành 28 × 28
Giải mã lô thành
hình ảnh chữ số
Lưới các chữ số được lấy mẫu (xem hình

8.14) cho thấy sự phân bố hoàn toàn
liên tục của các
các lớp chữ số, với một chữ số biến

thành chữ số khác khi bạn đi theo một
đường dẫn qua không gian tiềm ẩn. Các
hướng cụ thể trong không gian này có
một ý nghĩa: ví dụ: có một hướng cho
“bốn điểm”, “một điểm”, v.v.
Trong phần tiếp theo, chúng tôi sẽ
trình bày chi tiết về công cụ chính

khác để tạo ra các hình ảnh nhân tạo:
các mạng đối nghịch tạo ra (GAN).
Hình 8.14 Lưới các chữ số được giải mã từ không gian tiềm
ẩn

8.4.4 Kết thúc

Tạo hình ảnh với học sâu được thực hiện bằng cách học các không gian tiềm ẩn thu thập
thông tin thống kê về tập dữ liệu hình ảnh. Bằng cách lấy mẫu và giải mã các điểm từ
không gian tiềm ẩn, bạn có thể tạo ra những hình ảnh chưa từng thấy trước đây.
Có hai công cụ chính để thực hiện việc này: VAE và GAN.
VAE dẫn đến các biểu diễn tiềm ẩn liên tục, có cấu trúc cao. Vì lý do này, chúng hoạt động tốt
để thực hiện tất cả các loại chỉnh sửa hình ảnh trong không gian tiềm ẩn: hoán đổi khuôn
mặt, biến khuôn mặt cau có thành khuôn mặt tươi cười, v.v. Chúng cũng hoạt động độc đáo để
thực hiện các hoạt ảnh dựa trên không gian tiềm ẩn, chẳng hạn như tạo hoạt ảnh cho một cuộc
đi bộ dọc theo một mặt cắt ngang của không gian tiềm ẩn, hiển thị hình ảnh bắt đầu biến đổi
từ từ thành các hình ảnh khác nhau theo cách liên tục. GAN cho phép tạo ra các hình ảnh
đơn khung thực tế nhưng có thể không tạo ra các khoảng trống tiềm ẩn với cấu trúc vững chắc và
tính liên tục cao.
Hầu hết các ứng dụng thực tế thành công mà tôi từng thấy với hình ảnh đều dựa vào VAE, nhưng
GAN cực kỳ phổ biến trong thế giới nghiên cứu học thuật—ít nhất là vào khoảng năm 2016–2017.
Bạn sẽ tìm hiểu cách chúng hoạt động và cách triển khai chúng trong phần tiếp theo.
MẸO Để chơi xa hơn với việc tạo hình ảnh, tôi khuyên bạn nên làm việc với bộ dữ liệu
Thuộc tính khuôn mặt của người nổi tiếng (CelebA) quy mô lớn. Đó là bộ dữ liệu hình
ảnh tải xuống miễn phí chứa hơn 200.000 bức chân dung của người nổi tiếng. Thật tuyệt
vời khi thử nghiệm với các vectơ khái niệm nói riêng—nó chắc chắn đánh bại MNIST.

Giới thiệu về các mạng đối thủ chung 305
8.5 Giới thiệu về các mạng đối nghịch tổng quát Mạng đối nghịch tạo (GAN), được
giới thiệu vào năm 2014 bởi Goodfellow và cộng sự,8 là một giải pháp thay thế cho VAE để tìm hiểu các
không gian tiềm ẩn của hình ảnh. Chúng cho phép tạo ra các hình ảnh tổng hợp khá thực tế bằng cách buộc
các hình ảnh được tạo ra gần như không thể phân biệt được về mặt thống kê với hình ảnh thực.
Một cách trực quan để hiểu GAN là tưởng tượng một kẻ giả mạo đang cố gắng tạo ra một bức tranh
Picasso giả. Lúc đầu, người giả mạo thực hiện nhiệm vụ khá tệ. Anh ta trộn một số tác phẩm giả của mình
với những bức tranh Picasso thật và đưa tất cả chúng cho một nhà buôn nghệ thuật. Các đại lý nghệ thuật làm cho
đánh giá tính xác thực cho từng bức tranh và đưa ra phản hồi cho người làm giả về điều gì khiến một bức
tranh của Picasso trông giống một bức tranh của Picasso. Người làm đồ giả quay trở lại studio của mình
để chuẩn bị một số đồ giả mới. Thời gian trôi qua, người làm đồ giả ngày càng thành thạo trong việc bắt
chước phong cách của Picasso, và người buôn tranh ngày càng trở nên thành thạo trong việc phát hiện đồ giả.
Cuối cùng, họ có trong tay một số bức tranh Picasso giả xuất sắc.
Đó là bản chất của GAN : mạng giả mạo và mạng chuyên gia, mỗi mạng đều được đào tạo
để tốt nhất khác. Như vậy, một GAN được tạo thành từ hai phần:
Generator network—Lấy đầu vào là một vectơ ngẫu nhiên (một điểm ngẫu nhiên trong không gian tiềm
ẩn) và giải mã nó thành một hình ảnh tổng hợp Mạng phân biệt (hoặc đối thủ)—Lấy đầu vào là một
hình ảnh (thực hoặc tổng hợp) và dự đoán xem hình ảnh đến từ tập huấn luyện hoặc được tạo bởi mạng
máy phát.
Mạng trình tạo được đào tạo để có thể đánh lừa mạng phân biệt đối xử và do đó, nó phát triển theo hướng
tạo ra các hình ảnh ngày càng thực tế hơn khi quá trình đào tạo tiếp tục: hình ảnh nhân tạo trông không
thể phân biệt được với hình ảnh thực, đến mức mạng phân biệt đối xử không thể phân biệt chúng (xem hình
8.15). Trong khi đó, bộ phân biệt đối xử liên tục thích ứng với các khả năng cải tiến dần dần của trình
tạo, thiết lập mức độ chân thực cao cho hình ảnh được tạo. Sau khi đào tạo kết thúc, trình tạo có khả
năng biến bất kỳ điểm nào trong không gian đầu vào của nó thành một hình ảnh đáng tin cậy. Không giống
như VAE, không gian tiềm ẩn này ít đảm bảo rõ ràng hơn về cấu trúc có ý nghĩa; đặc biệt, nó không liên
tục.
số 8
Ian Goodfellow và cộng sự, “Mạng đối thủ sáng tạo,” arXiv (2014), https://arxiv.org/abs/1406.2661.

Vectơ ngẫu nhiên

Tạo (giải
từ không gian
mã) hình ảnh
tiềm ẩn
Máy phát điện (bộ giải mã)

phản hồi
đào tạo
phân biệt đối xử “Thật”, “Giả”
Kết hợp hình
ảnh thật và giả
Hình 8.15 Một bộ tạo chuyển đổi các vectơ tiềm ẩn ngẫu nhiên thành hình ảnh và bộ phân biệt tìm cách
phân biệt hình ảnh thực với những hình ảnh được tạo. Trình tạo được đào tạo để đánh lừa người phân biệt đối xử.
Đáng chú ý, GAN là một hệ thống không cố định mức tối ưu hóa tối thiểu, không giống
như trong bất kỳ thiết lập đào tạo nào khác mà bạn đã gặp trong cuốn sách này. Thông
thường, giảm độ dốc bao gồm lăn xuống đồi trong cảnh mất mát tĩnh. Nhưng với GAN, mỗi
bước đi xuống đồi sẽ thay đổi toàn bộ cảnh quan một chút. Đó là một hệ thống động
trong đó quá trình tối ưu hóa không tìm kiếm điểm tối thiểu, mà là trạng thái cân
bằng giữa hai lực. Vì lý do này, GAN nổi tiếng là khó đào tạo—để GAN hoạt động đòi
hỏi rất nhiều điều chỉnh cẩn thận về kiến trúc mô hình và các tham số đào tạo.
Hình 8.16 Cư dân không gian tiềm ẩn. Hình ảnh do Mike Tyka tạo bằng cách sử dụng
GAN nhiều tầng được đào tạo trên bộ dữ liệu khuôn mặt (www.miketyka.com).

8.5.1 Sơ đồ triển khai GAN

Trong phần này, chúng tôi sẽ giải thích cách triển khai GAN trong Keras, ở dạng đơn giản nhất— bởi
vì GAN là nâng cao nên việc đi sâu vào các chi tiết kỹ thuật sẽ nằm ngoài phạm vi của cuốn sách này.
Việc triển khai cụ thể là một GAN tích chập sâu (DCGAN): một GAN trong đó bộ tạo và bộ phân biệt đối
xử là các kết nối sâu. Cụ thể, nó sử dụng lớp Conv2DTranspose để lấy mẫu hình ảnh trong trình tạo.
Bạn sẽ huấn luyện GAN trên các hình ảnh từ CIFAR10, một bộ dữ liệu gồm 50.000 hình ảnh 32 × 32
RGB thuộc 10 lớp (5.000 hình ảnh mỗi lớp). Để làm cho mọi thứ dễ dàng hơn, bạn sẽ chỉ sử dụng những
hình ảnh thuộc về lớp “ếch”.
Về mặt sơ đồ, GAN trông giống như sau: 1
Mạng trình tạo ánh xạ các vectơ hình dạng (latent_dim,) thành các hình ảnh có hình dạng
(32, 32, 3).
2 Mạng phân biệt ánh xạ hình ảnh có hình dạng (32, 32, 3) thành điểm nhị phân
ước tính xác suất mà hình ảnh là có thật.
3 Một mạng gan xâu chuỗi bộ tạo và bộ phân biệt lại với nhau: gan(x) = bộ phân biệt (bộ tạo(x)).
Do đó, mạng gan này ánh xạ các vectơ không gian tiềm ẩn tới đánh giá của người phân biệt đối
xử về tính hiện thực của các vectơ tiềm ẩn này như
được giải mã bởi máy phát điện.
4 Bạn huấn luyện bộ phân biệt bằng cách sử dụng các ví dụ về hình ảnh thật và giả cùng với nhãn
“thật”/“giả”, giống như bạn huấn luyện bất kỳ mô hình phân loại hình ảnh thông thường nào.
5 Để đào tạo trình tạo, bạn sử dụng độ dốc của trọng số của trình tạo liên quan đến việc mất mô
hình gan . Điều này có nghĩa là, tại mỗi bước, bạn di chuyển các trọng số của bộ tạo theo
hướng khiến bộ phân biệt có nhiều khả năng phân loại các hình ảnh được bộ tạo giải mã là
“thực” hơn. Nói cách khác, bạn huấn luyện bộ tạo để đánh lừa bộ phân biệt đối xử.
8.5.2 Mưu mẹo

Quá trình đào tạo GAN và điều chỉnh việc triển khai GAN nổi tiếng là khó khăn. Có một số thủ thuật
đã biết mà bạn nên ghi nhớ. Giống như hầu hết mọi thứ trong deep learning, nó giống thuật giả kim
hơn là khoa học: những thủ thuật này là phương pháp phỏng đoán, không phải hướng dẫn dựa trên lý
thuyết. Chúng được hỗ trợ bởi mức độ hiểu biết trực quan về hiện tượng hiện có và chúng được biết là
hoạt động tốt theo kinh nghiệm, mặc dù không nhất thiết phải trong mọi ngữ cảnh.
Dưới đây là một số thủ thuật được sử dụng trong việc triển khai trình tạo và phân biệt đối xử
GAN trong phần này. Đây không phải là danh sách đầy đủ các mẹo liên quan đến GAN; bạn sẽ tìm thấy
nhiều hơn nữa trên tài liệu GAN :
Chúng tôi sử dụng tanh làm lần kích hoạt cuối cùng trong trình tạo, thay vì sigmoid, đó là
phổ biến hơn trong các loại mô hình khác.
Chúng tôi lấy mẫu các điểm từ không gian tiềm ẩn bằng cách sử dụng phân phối chuẩn (phân phối
Gaussian), không phải phân phối đồng đều.

Tính ngẫu nhiên rất tốt để tạo ra sự mạnh mẽ. Vì quá trình đào tạo GAN dẫn đến trạng thái
cân bằng động, nên GAN có thể gặp khó khăn theo mọi cách. Giới thiệu tính ngẫu nhiên trong
quá trình đào tạo giúp ngăn chặn điều này. Chúng tôi giới thiệu tính ngẫu nhiên theo hai
cách: bằng cách sử dụng dropout trong bộ phân biệt và bằng cách thêm nhiễu ngẫu nhiên vào
nhãn cho bộ phân biệt.
Độ dốc thưa thớt có thể cản trở quá trình đào tạo GAN . Trong học sâu, độ thưa thớt thường
là một thuộc tính mong muốn, nhưng không phải trong GAN. Hai điều có thể gây ra độ thưa của
gradient: hoạt động tổng hợp tối đa và kích hoạt ReLU . Thay vì tổng hợp tối đa, chúng tôi
khuyên bạn nên sử dụng các tổ hợp chập chững để lấy mẫu xuống và chúng tôi khuyên bạn nên
sử dụng lớp LeakyReLU thay vì kích hoạt ReLU . Nó tương tự như ReLU, nhưng nó nới lỏng các
ràng buộc về độ thưa thớt bằng cách cho phép các giá trị kích hoạt âm nhỏ. Trong các
hình ảnh được tạo ra, người ta thường thấy các tạo tác bàn cờ gây ra bởi độ bao phủ không đồng
đều của không gian pixel trong trình tạo (xem hình 8.17). Để khắc phục điều này, chúng tôi
sử dụng kích thước hạt nhân chia hết cho kích thước sải chân bất cứ khi nào chúng ta sử
dụng Conv2DTranpose hoặc Conv2D có sải chân trong cả trình tạo và trình phân biệt đối xử.
Hình 8.17 Tạo tác bàn cờ gây ra bởi bước tiến và kích thước hạt nhân không khớp, dẫn
đến phạm vi bao phủ không gian pixel không bằng nhau: một trong nhiều vấn đề của GAN
8.5.3 Máy phát điện

Đầu tiên, hãy phát triển một mô hình trình tạo để biến một vectơ (từ không gian tiềm ẩn—trong quá
trình đào tạo, nó sẽ được lấy mẫu ngẫu nhiên) thành một hình ảnh ứng cử viên. Một trong nhiều vấn
đề thường phát sinh với GAN là trình tạo bị kẹt với các hình ảnh được tạo giống như nhiễu. Một
giải pháp khả thi là sử dụng dropout trên cả bộ phân biệt và bộ tạo.
Liệt kê 8.29 Mạng máy phát GAN

máy ảnh nhập lớp nhập numpy dưới
dạng np
tiềm ẩn_dim = 32 chiều

cao = 32
chiều rộng = 32
kênh = 3

generator_input = keras.Input(shape=(latent_dim,))
x = layer.Dense(128 * 16 * 16)(generator_input) x = layer.LeakyReLU()(x) x Chuyển đổi đầu vào thành

= layer.Reshape((16, 16, 128))(x) bản đồ đặc trưng 16 × 16
128 kênh
x = layer.Conv2D(256, 5, padding='same')(x) x = layer.LeakyReLU()(x)
x = các lớp.Conv2DTranspose(256, 4, sải chân=2, đệm='same')(x) x = các lớp.LeakyReLU()(x) Lấy mẫu lên
32 × 32
x = layer.Conv2D(256, 5, padding='same')(x) x = layer.LeakyReLU()(x)

x = layer.Conv2D(256, 5, padding='same')(x) x = lớp.LeakyReLU()(x)
x = layer.Conv2D(channels, 7, activation='tanh', padding='same')(x) generator =

keras.models.Model(generator_input, x) generator.summary()
Tạo bản đồ đặc trưng 1 kênh 32 × 32
Khởi tạo mô hình trình tạo, ánh xạ đầu vào của hình dạng (hình dạng của ảnh CIFAR10)
(latent_dim,) thành một hình ảnh có hình dạng (32, 32, 3)
8.5.4 Bộ phân biệt đối xử
Tiếp theo, bạn sẽ phát triển một mô hình phân biệt lấy đầu vào là hình ảnh ứng cử viên
(thật hoặc tổng hợp) và phân loại nó thành một trong hai loại: “hình ảnh được tạo”
hoặc “hình ảnh thực đến từ tập huấn luyện”.
Liệt kê 8.30 Mạng phân biệt GAN
discriminator_input = các lớp.Input(shape=(chiều cao, chiều rộng, các kênh)) x = các lớp.Conv2D(128, 3)
(discriminator_input) x = các lớp.LeakyReLU()(x) x = các lớp.Conv2D(128, 4, sải chân =2)(x) x = các
lớp.LeakyReLU()(x) x = các lớp.Conv2D(128, 4, sải chân=2)(x) x = các lớp.LeakyReLU()(x) x = các
lớp.Conv2D(128 , 4, sải chân=2)(x) x = lớp.LeakyReLU()(x) x = lớp.Làm phẳng()(x)
Một lớp bỏ học: một

thủ thuật quan trọng!
lớp phân loại
x = layer.Dropout(0.4)(x)
Khởi tạo mô hình bộ khởi
x = layer.Dense(1, activation='sigmoid')(x) tạo phân biệt, biến đầu
vào (32, 32, 3) thành quyết
discriminator = keras.models.Model(discriminator_input, x) discriminator.summary()
định phân loại nhị phân
(giả/thật)
discriminator_optimizer = keras.optimizers.RMSprop(
lr=0,0008, Sử dụng tính năng cắt gradient (theo
giá trị) trong trình tối ưu hóa

clipvalue=1,0, phân
rã=1e-8)
Để ổn định đào tạo,

discriminator.compile(optimizer=discriminator_optimizer, loss='binary_crossentropy')
sử dụng phân rã tỷ lệ học tập

8.5.5 Mạng đối thủ
Cuối cùng, bạn sẽ thiết lập GAN, chuỗi này sẽ xâu chuỗi bộ tạo và bộ phân biệt đối xử.
Khi được đào tạo, mô hình này sẽ di chuyển bộ tạo theo hướng giúp cải thiện khả năng đánh lừa
bộ phân biệt đối xử. Mô hình này biến các điểm không gian tiềm ẩn thành một quyết định phân loại
—“giả” hoặc “thật”—và nó được huấn luyện với các nhãn luôn là “đây là những hình ảnh thực”. Vì
vậy, đào tạo gan sẽ cập nhật các trọng số của trình tạo theo cách khiến cho bộ phân biệt đối xử
có nhiều khả năng dự đoán “thật” hơn khi nhìn vào các hình ảnh giả.
Điều rất quan trọng cần lưu ý là bạn đặt bộ phân biệt bị đóng băng trong quá trình huấn luyện
(không thể huấn luyện): trọng số của nó sẽ không được cập nhật khi huấn luyện gan. Nếu các trọng
số của bộ phân biệt có thể được cập nhật trong quá trình này, thì bạn sẽ huấn luyện bộ phân biệt
để luôn dự đoán “thực”, đó không phải là điều bạn muốn!
Liệt kê 8.31 Mạng đối thủ
discriminator.trainable = Sai
Đặt trọng số của bộ phân biệt đối xử
gan_input = keras.Input(shape=(latent_dim,)) gan_output = thành không thể huấn luyện (điều này
discriminator(generator(gan_input)) gan = keras.models.Model(gan_input, sẽ chỉ áp dụng cho mô hình gan)
gan_output)
gan_optimizer = keras.optimizers.RMSprop(lr=0.0004, clipvalue=1.0, phân rã=1e-8) gan.compile(optimizer=gan_optimizer,

loss='binary_crossentropy')
8.5.6 Cách huấn luyện DCGAN của bạn
Bây giờ bạn có thể bắt đầu đào tạo. Tóm lại, đây là sơ đồ của vòng huấn luyện. Đối với mỗi kỷ
nguyên, bạn làm như sau:
1 Vẽ các điểm ngẫu nhiên trong không gian ẩn (nhiễu ngẫu nhiên).
2 Tạo ảnh bằng trình tạo bằng cách sử dụng nhiễu ngẫu nhiên này.
3 Trộn các hình ảnh được tạo với hình ảnh thực.
4 Huấn luyện bộ phân biệt bằng cách sử dụng các hình ảnh hỗn hợp này, với các mục tiêu tương
ứng: “thực” (đối với hình ảnh thực) hoặc “giả” (đối với hình ảnh được tạo).
5 Vẽ các điểm ngẫu nhiên mới trong không gian tiềm ẩn.
6 Huấn luyện gan bằng cách sử dụng các vectơ ngẫu nhiên này, với các mục tiêu đều nói rằng
“đây là những hình ảnh thực tế”. Điều này cập nhật các trọng số của bộ tạo (chỉ vì bộ
phân biệt bị đóng băng bên trong gan) để di chuyển chúng theo hướng khiến bộ phân biệt
dự đoán “đây là những hình ảnh thực” cho các hình ảnh được tạo: điều này đào tạo bộ tạo
để đánh lừa bộ phân biệt.
Hãy thực hiện nó.
Liệt kê 8.32 Triển khai đào tạo GAN
nhập os từ
Tải dữ liệu CIFAR10
keras.tiền xử lý hình ảnh nhập
(x_train, y_train), (_, _) = keras.datasets.cifar10.load_data()

x_train = x_train[y_train.flatten() == 6]
Chọn lọc hình ảnh con ếch (lớp 6)
x_train = x_train.reshape( (x_train.shape[0],)
+ (chiều cao, chiều rộng,

Chuẩn hóa dữ liệu
kênh)).astype('float32')/255.
số lần lặp = 10000
batch_size = 20 save_dir
= 'your_dir'
Chỉ định nơi bạn muốn lưu hình
ảnh đã tạo
bắt đầu = 0
cho bước trong phạm vi (lặp lại): Lấy mẫu các điểm
random_latent_vectors = np.random.normal(size=(batch_size,latent_dim)) ngẫu nhiên trong
không gian tiềm ẩn
Giải mã created_images = generator.predict(random_latent_vector)
chúng Kết hợp chúng với
thành dừng = bắt đầu + batch_size real_images hình ảnh thực
hình ảnh giả mạo = x_train[bắt đầu: dừng] kết hợp_hình ảnh =
np.concatenate([hình_ảnh_tạo, hình_ảnh thực])
Ghép nhãn, phân biệt hình ảnh

nhãn = np.concatenate([np.ones((batch_size, 1)), np.zeros((batch_size, 1))])
thật và giả
nhãn += 0,05 * np.random.random(nhãn.shape)

Thêm tiếng ồn
ngẫu nhiên vào

Đào tạo người d_loss = discriminator.train_on_batch(kết_hợp_hình_ảnh, nhãn)
nhãn—một thủ
phân biệt đối xử
random_latent_vectors = np.random.normal(size=(batch_size,latent_dim)) thuật quan trọng!
Lấy mẫu các điểm
ngẫu nhiên trong
Tập hợp các false_targets = np.zeros((batch_size, 1)) không gian tiềm ẩn
nhãn có nội
dung “đây
a_loss = gan.train_on_batch(random_latent_vectors, false_targets) Huấn luyện bộ tạo (thông qua mô
đều là hình hình gan, trong đó các trọng số của
ảnh bộ tạo phân biệt đối xử bị đóng băng)

bắt đầu += batch_size nếu bắt
thật” (đó là lời nói dối!)
đầu > len(x_train) - batch_size:
bắt đầu = 0 Thỉnh thoảng lưu và vẽ sơ
đồ (cứ sau 100 bước)
nếu bước % 100 == 0:
gan.save_weights('gan.h5') Tiết kiệm trọng lượng mô hình
Lưu một
print('discriminator loss:', d_loss) print('adversarial
Số liệu in hình ảnh được tạo
loss:', a_loss)
img = image.array_to_img(generated_images[0] * 255., scale=False) img.save(os.path.join(save_dir,
'generated_frog' + str(bước) + '.png'))
img = image.array_to_img(real_images[0] * 255., scale=False) img.save(os.path.join(save_dir,
'real_frog' + str(step) + '.png'))
Lưu một hình ảnh thật để
so sánh

Khi huấn luyện, bạn có thể thấy tổn thất do đối thủ bắt đầu tăng lên đáng kể, trong khi tổn
thất do phân biệt đối xử có xu hướng bằng 0—kẻ phân biệt đối xử cuối cùng có thể thống trị
máy phát. Nếu đúng như vậy, hãy thử giảm tỷ lệ học tập của người phân biệt đối xử và tăng
tỷ lệ bỏ học của người phân biệt đối xử.
Hình 8.18 Chơi bộ phân biệt: trong mỗi hàng, hai hình ảnh được mơ hình bởi GAN và một hình ảnh đến
từ tập huấn luyện. Bạn có thể phân biệt chúng không? (Đáp án: hình ảnh thật trong mỗi cột là giữa,
trên, dưới, giữa.)
8.5.7 Kết thúc

Một GAN bao gồm một mạng tạo kết hợp với một mạng phân biệt.
Bộ phân biệt được đào tạo để phân biệt giữa đầu ra của trình tạo và hình ảnh thực từ
tập dữ liệu huấn luyện và bộ tạo được đào tạo để đánh lừa bộ phân biệt. Đáng chú ý,
trình tạo không bao giờ nhìn thấy hình ảnh trực tiếp từ tập huấn luyện; thông tin nó
có về dữ liệu đến từ bộ phân biệt đối xử. GAN rất khó đào tạo, bởi vì đào tạo GAN
là một quy trình động chứ không phải là một quy trình giảm dần độ dốc đơn giản với bối
cảnh tổn thất cố định. Để GAN huấn luyện chính xác, yêu cầu sử dụng một số thủ thuật
khám phá cũng như điều chỉnh rộng rãi. GAN có khả năng tạo ra hình ảnh có độ chân
thực cao. Nhưng không giống như VAE, không gian tiềm ẩn mà chúng học không có cấu
trúc liên tục gọn gàng và do đó có thể không phù hợp với một số ứng dụng thực tế, chẳng
hạn như chỉnh sửa hình ảnh thông qua các vectơ khái niệm không gian tiềm ẩn.

Tóm tắt chương Với
các ứng dụng sáng tạo của học sâu, các mạng sâu vượt ra ngoài việc chú thích nội
dung hiện có và bắt đầu tạo nội dung của riêng chúng. Bạn đã học được những
điều sau: – Cách tạo dữ liệu trình tự, mỗi lần một dấu thời gian. Điều này có
thể áp dụng cho việc tạo văn bản cũng như tạo nhạc theo từng nốt nhạc hoặc bất
kỳ loại dữ liệu chuỗi thời gian nào khác.
– Cách thức hoạt động của DeepDream: bằng cách tối đa hóa kích hoạt lớp convnet thông qua độ
dốc tăng dần trong không gian đầu vào.
– Cách thực hiện chuyển kiểu, trong đó hình ảnh nội dung và hình ảnh kiểu được kết hợp để tạo
ra kết quả trông thú vị.
– GAN và VAE là gì, chúng có thể được sử dụng như thế nào để tạo ra các hình ảnh mới và cách
sử dụng các vectơ khái niệm không gian tiềm ẩn để chỉnh sửa hình ảnh. Một số kỹ thuật
này chỉ đề cập đến những điều cơ bản của lĩnh vực đang phát triển nhanh chóng này.
Ngoài kia còn rất nhiều điều để khám phá—học sâu sáng tạo xứng đáng có cả một cuốn sách riêng.

kết luận
Những điều rút ra quan trọng từ cuốn
sách này Những hạn chế của deep learning
Tương lai của deep learning, machine learning,

và trí tuệ nhân tạo
Tài nguyên để học thêm và làm việc trong

cánh đồng
Bạn đã đọc gần hết cuốn sách này. Chương cuối cùng này sẽ tóm tắt và xem xét các khái niệm
cốt lõi đồng thời mở rộng tầm nhìn của bạn ngoài những khái niệm tương đối cơ bản mà bạn đã
học cho đến nay. Hiểu về deep learning và AI là một hành trình, và hoàn thành cuốn sách này
chỉ là bước đầu tiên trên hành trình đó. Tôi muốn đảm bảo rằng bạn nhận ra điều này và được
trang bị đầy đủ để tự mình thực hiện các bước tiếp theo của hành trình này.
Chúng ta sẽ bắt đầu với cái nhìn toàn cảnh về những gì bạn nên rút ra từ cuốn sách này.
Điều này sẽ làm mới bộ nhớ của bạn về một số khái niệm bạn đã học.
Tiếp theo, chúng tôi sẽ trình bày tổng quan về một số hạn chế chính của học sâu. Để sử dụng
một công cụ một cách thích hợp, bạn không chỉ hiểu những gì nó có thể làm mà còn nhận thức
được những gì nó không thể làm. Cuối cùng, tôi sẽ đưa ra một số suy nghĩ mang tính suy đoán
về sự phát triển trong tương lai của các lĩnh vực học sâu, học máy và AI. Điều này sẽ đặc
biệt thú vị đối với bạn nếu bạn muốn tham gia nghiên cứu cơ bản. Chương này kết thúc với một
danh sách ngắn các tài nguyên và chiến lược để tìm hiểu thêm về AI và cập nhật những tiến bộ
mới.
314

Các khái niệm chính trong đánh giá

315
9.1 Các khái niệm chính khi xem

xét Phần này tổng hợp ngắn gọn những điểm chính rút ra từ cuốn sách này. Nếu
bạn cần ôn lại nhanh để nhớ lại những gì đã học, bạn có thể đọc vài trang này.
9.1.1 Các cách tiếp cận AI khác nhau
Trước hết, học sâu không đồng nghĩa với AI hay thậm chí là học máy.
Trí tuệ nhân tạo là một lĩnh vực cổ xưa, rộng lớn, thường có thể được định nghĩa là “tất cả
các nỗ lực để tự động hóa các quy trình nhận thức” — nói cách khác, tự động hóa suy nghĩ.
Điều này có thể bao gồm từ rất cơ bản, chẳng hạn như bảng tính Excel, đến rất nâng cao,
chẳng hạn như rô-bốt hình người có thể đi lại và nói chuyện.
Học máy là một lĩnh vực con cụ thể của AI nhằm mục đích tự động phát triển các chương
trình (được gọi là mô hình) hoàn toàn từ việc tiếp xúc với dữ liệu đào tạo. Quá trình biến
dữ liệu thành một chương trình này được gọi là học. Mặc dù học máy đã xuất hiện từ lâu,
nhưng nó chỉ bắt đầu cất cánh vào những năm 1990.
Học sâu là một trong nhiều nhánh của học máy, trong đó các mô hình là chuỗi dài các hàm
hình học, được áp dụng lần lượt. Các hoạt động này được cấu trúc thành các mô-đun được gọi
là các lớp: các mô hình học sâu thường là các chồng lớp—hay nói chung hơn là biểu đồ của
các lớp. Các lớp này được tham số hóa theo trọng số, là các tham số đã học được trong quá
trình đào tạo. Kiến thức về một mô hình được lưu trữ trong các trọng số của nó và quá trình
học tập bao gồm việc tìm kiếm các giá trị tốt cho các trọng số này.
Mặc dù học sâu chỉ là một trong nhiều cách tiếp cận máy học, nhưng nó không ngang hàng
với những cách khác. Học sâu là một thành công đột phá.
Đây là lý do tại sao.
9.1.2 Điều gì khiến deep learning trở nên đặc

biệt trong lĩnh vực machine learning
Chỉ trong vòng vài năm, học sâu đã đạt được những bước đột phá to lớn trong nhiều nhiệm vụ
trước đây được coi là cực kỳ khó khăn đối với máy tính, đặc biệt là trong lĩnh vực nhận
thức của máy: trích xuất thông tin hữu ích từ hình ảnh, video, âm thanh , và nhiều hơn nữa.
Được cung cấp đủ dữ liệu đào tạo (đặc biệt là dữ liệu đào tạo do con người gắn nhãn thích
hợp), có thể trích xuất hầu hết mọi thứ mà con người có thể trích xuất từ dữ liệu tri giác.
Do đó, đôi khi người ta nói rằng học sâu đã giải quyết được nhận thức, mặc dù điều đó chỉ
đúng với một định nghĩa khá hẹp về nhận thức.
Do những thành công kỹ thuật chưa từng có của nó, deep learning đã tự tay mang lại mùa
hè AI thứ ba và lớn nhất cho đến nay: một giai đoạn thu hút nhiều sự quan tâm, đầu tư và
cường điệu trong lĩnh vực AI. Khi cuốn sách này đang được viết, chúng ta đang ở giữa chừng.
Liệu giai đoạn này sẽ kết thúc trong tương lai gần hay không, và điều gì xảy ra sau khi nó
kết thúc, là những chủ đề tranh luận. Có một điều chắc chắn: trái ngược hoàn toàn với các
mùa hè AI trước đây , học sâu đã mang lại giá trị kinh doanh to lớn cho một số công ty công
nghệ lớn, cho phép nhận dạng giọng nói ở cấp độ con người, trợ lý thông minh, cấp độ con người.

316 CHƯƠNG 9 Kết luận
phân loại hình ảnh, dịch máy được cải thiện rất nhiều, v.v. Sự cường điệu có thể (và có khả
năng sẽ) giảm đi, nhưng tác động kinh tế và công nghệ bền vững của học sâu sẽ vẫn còn. Theo
nghĩa đó, học sâu có thể tương tự như internet: nó có thể được thổi phồng quá mức trong một
vài năm, nhưng về lâu dài, nó vẫn sẽ là một cuộc cách mạng lớn sẽ thay đổi nền kinh tế và cuộc
sống của chúng ta.
Tôi đặc biệt lạc quan về học sâu vì ngay cả khi chúng ta không đạt được tiến bộ công nghệ
nào nữa trong thập kỷ tới, thì việc triển khai các thuật toán hiện có cho mọi vấn đề có thể áp
dụng sẽ là yếu tố thay đổi cuộc chơi đối với hầu hết các ngành. Học sâu không khác gì một cuộc
cách mạng và tiến độ hiện đang diễn ra với tốc độ cực kỳ nhanh, do đầu tư theo cấp số nhân vào
tài nguyên và số lượng nhân viên. Từ vị trí của tôi, tương lai có vẻ tươi sáng, mặc dù những
kỳ vọng ngắn hạn có phần lạc quan quá mức; triển khai học sâu đến mức tối đa tiềm năng của nó
sẽ mất hơn một thập kỷ.
9.1.3 Cách suy nghĩ về học sâu
Điều đáng ngạc nhiên nhất về deep learning là nó đơn giản như thế nào. Mười năm trước, không
ai ngờ rằng chúng ta sẽ đạt được những kết quả đáng kinh ngạc như vậy đối với các vấn đề về
nhận thức của máy bằng cách sử dụng các mô hình tham số đơn giản được đào tạo với độ dốc giảm
dần. Bây giờ, hóa ra tất cả những gì bạn cần là các mô hình tham số đủ lớn được đào tạo với độ
dốc giảm dần trên đủ nhiều ví dụ. Như Feynman đã từng nói về vũ trụ, “Vũ trụ không phức tạp,
nó chỉ là rất nhiều.”1
Trong học sâu, mọi thứ đều là một vectơ: mọi thứ đều là một điểm trong không gian hình học.
Các đầu vào mô hình (văn bản, hình ảnh, v.v.) và các mục tiêu được vector hóa đầu tiên: biến
thành không gian vectơ đầu vào ban đầu và không gian vectơ đích. Mỗi lớp trong mô hình học sâu
vận hành một phép biến đổi hình học đơn giản trên dữ liệu đi qua nó.
Cùng với nhau, chuỗi các lớp trong mô hình tạo thành một phép biến đổi hình học phức tạp, được
chia nhỏ thành một loạt các lớp đơn giản. Phép biến đổi phức tạp này cố gắng ánh xạ không gian
đầu vào sang không gian đích, mỗi lần một điểm. Quá trình chuyển đổi này được tham số hóa bằng
trọng số của các lớp, được cập nhật lặp lại dựa trên mức độ hiệu quả của mô hình hiện tại. Một
đặc điểm chính của phép biến đổi hình học này là nó phải khả vi, điều này cần thiết để chúng
ta có thể tìm hiểu các tham số của nó thông qua việc giảm dần độ dốc. Theo trực giác, điều này
có nghĩa là sự biến đổi hình học từ đầu vào đến đầu ra phải trơn tru và liên tục—một hạn chế
đáng kể.
Toàn bộ quá trình áp dụng phép biến đổi hình học phức tạp này cho dữ liệu đầu vào có thể
được hiển thị dưới dạng 3D bằng cách tưởng tượng một người đang cố gắng vò nát một quả bóng
giấy: quả bóng giấy bị vò nát là tập hợp dữ liệu đầu vào mà mô hình bắt đầu sử dụng.
Mỗi chuyển động do người trên quả bóng giấy vận hành tương tự như một phép biến đổi số liệu
địa lý đơn giản được vận hành bởi một lớp. Chuỗi cử chỉ hoàn chỉnh đầy đủ là sự biến đổi phức
tạp của toàn bộ mô hình. Các mô hình học sâu là những cỗ máy toán học để giải mã các đa tạp
phức tạp của dữ liệu nhiều chiều.
1
Richard Feynman, phỏng vấn, Thế giới từ một góc nhìn khác, Truyền hình Yorkshire, 1972.


317
Đó là điều kỳ diệu của học sâu: biến ý nghĩa thành vectơ, thành không gian hình học, sau
đó học dần các phép biến đổi hình học phức tạp để ánh xạ không gian này sang không gian khác.
Tất cả những gì bạn cần là không gian có kích thước đủ cao để nắm bắt toàn bộ phạm vi của các
mối quan hệ được tìm thấy trong dữ liệu gốc.
Toàn bộ vấn đề xoay quanh một ý tưởng cốt lõi duy nhất: ý nghĩa đó bắt nguồn từ mối quan
hệ theo cặp giữa các sự vật (giữa các từ trong một ngôn ngữ, giữa các pixel trong một hình
ảnh, v.v.) và những mối quan hệ này có thể được nắm bắt bởi một hàm khoảng cách. Nhưng lưu ý
rằng liệu bộ não có thực hiện ý nghĩa thông qua không gian hình học hay không lại là một câu
hỏi hoàn toàn riêng biệt. Không gian vectơ hoạt động hiệu quả từ quan điểm tính toán, nhưng
các cấu trúc dữ liệu khác nhau cho trí thông minh có thể dễ dàng được hình dung—cụ thể là đồ
thị. Mạng lưới thần kinh ban đầu xuất hiện từ ý tưởng sử dụng đồ thị như một cách để mã hóa ý
nghĩa, đó là lý do tại sao chúng được đặt tên là mạng lưới thần kinh; lĩnh vực nghiên cứu xung
quanh từng được gọi là chủ nghĩa kết nối. Ngày nay, cái tên mạng nơ-ron tồn tại hoàn toàn vì
những lý do lịch sử—đó là một cái tên cực kỳ dễ gây hiểu lầm bởi vì chúng không phải là mạng
nơ-ron hay mạng. Đặc biệt, mạng lưới thần kinh hầu như không liên quan gì đến bộ não. Một cái
tên thích hợp hơn sẽ là học các biểu diễn phân lớp hoặc học các biểu diễn phân cấp, hoặc thậm
chí có thể là các mô hình khả vi sâu hoặc các phép biến đổi hình học xâu chuỗi, để nhấn mạnh
thực tế rằng thao tác không gian hình học liên tục là cốt lõi của chúng.
9.1.4 Các công nghệ kích hoạt chính
Cuộc cách mạng công nghệ hiện đang diễn ra không bắt đầu với bất kỳ phát minh đột phá nào.
Thay vào đó, giống như bất kỳ cuộc cách mạng nào khác, nó là sản phẩm của sự tích lũy rộng
lớn các yếu tố thuận lợi—lúc đầu diễn ra từ từ, sau đó đột ngột. Trong trường hợp học sâu,
chúng ta có thể chỉ ra các yếu tố chính sau:
Các đổi mới thuật toán gia tăng, lần đầu tiên trải rộng trong hai thập kỷ (bắt đầu bằng
lan truyền ngược) và sau đó diễn ra ngày càng nhanh hơn khi nhiều nỗ lực nghiên cứu
được đổ vào học sâu sau năm 2012.
Sự sẵn có của một lượng lớn dữ liệu tri giác, đó là một yêu cầu để nhận ra rằng các mô
hình đủ lớn được đào tạo trên dữ liệu đủ lớn là tất cả những gì chúng ta cần. Đến lượt
nó, đây là sản phẩm phụ của sự gia tăng của Internet dành cho người tiêu dùng và định
luật Moore được áp dụng cho phương tiện lưu trữ.
Sự sẵn có của phần cứng tính toán song song cao, tốc độ cao với giá thấp, đặc biệt là
GPU do NVIDIA sản xuất—đầu tiên là GPU chơi game và sau đó là chip được thiết kế từ
đầu cho học sâu. Ngay từ đầu, Giám đốc điều hành NVIDIA Jensen Huang đã lưu ý đến sự
bùng nổ của deep learning và quyết định đặt cược tương lai của công ty vào đó.
Một tập hợp các lớp phần mềm phức tạp cung cấp sức mạnh tính toán này cho con người:
ngôn ngữ CUDA , các khung như TensorFlow thực hiện phân biệt tự động và Keras, giúp
hầu hết mọi người có thể tiếp cận học sâu.

Trong tương lai, học sâu sẽ không chỉ được sử dụng bởi các chuyên gia—nhà nghiên cứu, sinh viên mới tốt
nghiệp và kỹ sư có trình độ học vấn—mà còn là một công cụ trong hộp công cụ của mọi nhà phát triển, giống
như công nghệ web ngày nay. Mọi người cần xây dựng các ứng dụng thông minh: giống như mọi doanh nghiệp ngày
nay đều cần một trang web, mọi sản phẩm sẽ cần hiểu ý nghĩa của dữ liệu do người dùng tạo một cách thông
minh. Mang lại tương lai này sẽ yêu cầu chúng tôi xây dựng các công cụ giúp học sâu hoàn toàn dễ sử dụng
và có thể truy cập được đối với bất kỳ ai có khả năng viết mã cơ bản. Keras là bước quan trọng đầu tiên
theo hướng đó.
9.1.5 Quy trình học máy toàn cầu
Có quyền truy cập vào một công cụ cực kỳ mạnh mẽ để tạo các mô hình ánh xạ bất kỳ không gian đầu vào nào
tới bất kỳ không gian đích nào là điều tuyệt vời, nhưng phần khó khăn của quy trình công việc học máy
thường là mọi thứ xuất hiện trước khi thiết kế và đào tạo các mô hình đó (và đối với các mô hình sản xuất ,
cái gì đến sau cũng vậy). Hiểu miền vấn đề để có thể xác định những gì cần cố gắng dự đoán, cung cấp dữ
liệu nào và cách đo lường thành công, là điều kiện tiên quyết cho bất kỳ ứng dụng học máy thành công nào và
đó không phải là thứ mà các công cụ tiên tiến như Keras và TensorFlow có thể giúp bạn với. Xin nhắc lại,
đây là tóm tắt nhanh về quy trình học máy điển hình như được mô tả trong chương 4:
1 Xác định vấn đề: Dữ liệu nào có sẵn và bạn đang cố gắng dự đoán điều gì?
Bạn sẽ cần thu thập thêm dữ liệu hay thuê người để gắn nhãn tập dữ liệu theo cách thủ công?
2 Xác định một cách đáng tin cậy để đo lường thành công trên mục tiêu của bạn. Đối với các tác vụ đơn
giản, đây có thể là độ chính xác của dự đoán, nhưng trong nhiều trường hợp, nó sẽ yêu cầu các số
liệu phức tạp dành riêng cho miền.
3 Chuẩn bị quy trình xác thực mà bạn sẽ sử dụng để đánh giá các mô hình của mình. Cụ thể, bạn nên xác
định tập huấn luyện, tập hợp lệ và tập kiểm tra. Các nhãn xác thực và tập kiểm tra không được rò
rỉ vào dữ liệu đào tạo: ví dụ: với dự đoán thời gian, dữ liệu kiểm tra và xác thực phải ở sau dữ
liệu đào tạo.
4 Vector hóa dữ liệu bằng cách biến nó thành các vectơ và tiền xử lý dữ liệu theo cách giúp mạng nơ-ron
tiếp cận dữ liệu dễ dàng hơn (chuẩn hóa, v.v.).
5 Phát triển một mô hình đầu tiên đánh bại một đường cơ sở thông thường tầm thường, từ đó chứng minh
rằng học máy có thể giải quyết vấn đề của bạn. Điều này có thể không phải lúc nào cũng đúng!
6 Dần dần tinh chỉnh kiến trúc mô hình của bạn bằng cách điều chỉnh các siêu tham số và thêm chính quy
hóa. Chỉ thực hiện các thay đổi dựa trên hiệu suất trên dữ liệu xác thực, không phải dữ liệu thử
nghiệm hoặc dữ liệu huấn luyện. Hãy nhớ rằng bạn nên làm cho mô hình của mình ở trạng thái overfit
(do đó xác định mức dung lượng mô hình lớn hơn mức bạn cần) và chỉ sau đó mới bắt đầu thêm quy
chuẩn hóa hoặc thu nhỏ kích thước mô hình của bạn.


319
7 Lưu ý về việc khớp quá mức bộ xác thực khi chuyển đổi siêu tham số: thực tế là
siêu tham số của bạn có thể bị chuyên môn hóa quá mức đối với bộ xác thực.
Tránh điều này là mục đích của việc có một bộ kiểm tra riêng!
9.1.6 Kiến trúc mạng chính
Ba họ kiến trúc mạng mà bạn nên làm quen là mạng kết nối dày đặc, mạng tích chập và mạng
hồi quy. Mỗi loại mạng dành cho một phương thức đầu vào cụ thể: kiến trúc mạng (dày đặc,
tích chập, lặp lại) mã hóa các giả định về cấu trúc của dữ liệu: một không gian giả thuyết
trong đó quá trình tìm kiếm một mô hình tốt sẽ được tiến hành. Việc một kiến trúc nhất định
có hoạt động với một vấn đề nhất định hay không hoàn toàn phụ thuộc vào sự phù hợp giữa cấu
trúc của dữ liệu và các giả định của kiến trúc mạng.
Có thể dễ dàng kết hợp các loại mạng khác nhau này để đạt được các mạng đa phương thức
lớn hơn, giống như bạn kết hợp các viên gạch LEGO . Theo một cách nào đó, các lớp học sâu
là những viên gạch LEGO để xử lý thông tin. Dưới đây là tổng quan nhanh về ánh xạ giữa các
phương thức đầu vào và kiến trúc mạng thích hợp: Dữ liệu vectơ —Mạng được kết nối dày
đặc (Các lớp dày đặc). Dữ liệu hình ảnh—các kết nối 2D . Dữ liệu âm thanh (ví dụ:
dạng sóng)—Kết nối 1D (ưu tiên) hoặc RNN. Dữ liệu văn bản —Hoặc là kết nối 1D (ưu
tiên) hoặc RNN. Dữ liệu chuỗi thời gian — RNN (ưu tiên) hoặc kết nối 1D . Các
loại dữ liệu trình tự khác— RNNs hoặc 1D convnets. Ưu tiên RNN nếu thứ tự dữ liệu có
ý nghĩa mạnh mẽ (ví dụ: đối với chuỗi thời gian, nhưng không phải đối với văn bản).
Dữ liệu video —Có thể là hội tụ 3D (nếu bạn cần ghi lại các hiệu ứng chuyển động) hoặc
sự kết hợp của hội nghị 2D ở mức khung hình để trích xuất tính năng, sau đó là hội
nghị RNN hoặc hội nghị 1D để xử lý chuỗi kết quả.
Dữ liệu thể tích—3D convnets.
Bây giờ, hãy nhanh chóng xem xét các đặc điểm của từng kiến trúc mạng.
MẠNG LƯỚI DUY NHẤT
Một mạng được kết nối dày đặc là một tập hợp các lớp Mật độ cao, dùng để xử lý dữ liệu
vectơ (các lô vectơ). Các mạng như vậy giả định không có cấu trúc cụ thể trong các tính
năng đầu vào: chúng được gọi là kết nối dày đặc vì các đơn vị của lớp Mật độ cao được kết
nối với mọi đơn vị khác. Lớp cố gắng ánh xạ mối quan hệ giữa hai tính năng đầu vào bất kỳ;
chẳng hạn, điều này không giống như lớp tích chập 2D chỉ xem xét các mối quan hệ cục bộ.
Các mạng kết nối dày đặc được sử dụng phổ biến nhất cho dữ liệu phân loại (ví dụ: trong
đó các tính năng đầu vào là danh sách các thuộc tính), chẳng hạn như bộ dữ liệu Giá nhà ở
Boston được sử dụng trong chương 3. Chúng cũng được sử dụng làm giai đoạn phân loại hoặc
hồi quy cuối cùng của hầu hết các mạng. Chẳng hạn, các kết nối được đề cập trong chương 5
thường kết thúc bằng một hoặc hai lớp Dense và các mạng hồi quy trong chương 6 cũng vậy.

Hãy nhớ rằng: để thực hiện phân loại nhị phân, hãy kết thúc ngăn xếp các lớp của bạn bằng
một Lớp dày đặc với một đơn vị và kích hoạt sigmoid , đồng thời sử dụng binary_crossentropy
làm tổn thất. Mục tiêu của bạn phải là 0 hoặc 1:
từ các mô hình nhập máy ảnh

model = models.Sequential()
model.add(layers.Dense(32, activation='relu', input_shape=(num_input_features,)))
model.add(layers.Dense(32, activation='relu')) model. add(layers.Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy')
Để thực hiện phân loại theo nhãn đơn (trong đó mỗi mẫu có chính xác một lớp, không nhiều hơn),
hãy kết thúc ngăn xếp các lớp của bạn bằng một Lớp dày đặc có số lượng đơn vị bằng với số
lượng lớp và kích hoạt softmax . Nếu các mục tiêu của bạn được mã hóa một lần nóng, hãy sử
dụng categorical_crossentropy làm mất mát; nếu chúng là số nguyên, hãy sử dụng Spare_categorical_
crossentropy:
model.add(layers.Dense(32, activation='relu')) model. add(layers.Dense(num_classes, activation='softmax'))
Để thực hiện phân loại phân loại nhiều nhãn (trong đó mỗi mẫu có thể có một số lớp), hãy kết
thúc ngăn xếp lớp của bạn bằng Lớp dày đặc có số đơn vị bằng với số lớp và kích hoạt sigmoid ,
đồng thời sử dụng binary_crossentropy làm tổn thất.
Mục tiêu của bạn phải được mã hóa k-hot:
model.add(layers.Dense(32, activation='relu')) model. add(layers.Dense(num_classes, activation='sigmoid'))
Để thực hiện hồi quy đối với một vectơ có các giá trị liên tục, hãy kết thúc ngăn xếp các lớp
của bạn bằng một Lớp dày đặc có số đơn vị bằng với số giá trị bạn đang cố gắng dự đoán (thường
là một giá trị duy nhất, chẳng hạn như giá của một ngôi nhà) và không kích hoạt. Một số tổn
thất có thể được sử dụng để hồi quy, phổ biến nhất là mean_squared_error (MSE) và
mean_absolute_error (MAE):
model.add(layers.Dense(32, activation='relu')) model. add(layers.Dense(num_values))
model.compile(optimizer='rmsprop', loss='mse')

Các khái niệm chính trong đánh giá 321
CONVNETS
Các lớp tích chập xem xét các mẫu cục bộ trong không gian bằng cách áp dụng cùng một phép
biến đổi hình học cho các vị trí không gian khác nhau (các bản vá) trong một tenxơ đầu
vào. Điều này dẫn đến các biểu diễn là bất biến dịch thuật, làm cho các lớp tích chập có
hiệu quả dữ liệu cao và theo mô đun. Ý tưởng này có thể áp dụng cho các không gian có bất
kỳ chiều nào: 1D (trình tự), 2D (hình ảnh), 3D (khối lượng), v.v. Bạn có thể sử dụng lớp
Conv1D để xử lý trình tự (đặc biệt là văn bản—lớp này không hoạt động tốt trên chuỗi thời
gian, thường không tuân theo giả định bất biến dịch mã), lớp Conv2D để xử lý hình ảnh và
lớp Conv3D để xử lý khối lượng .
Convnets, hoặc mạng tích chập, bao gồm các lớp tích chập và lớp tổng hợp tối đa. Các
lớp tổng hợp cho phép bạn lấy mẫu dữ liệu theo không gian, điều này cần thiết để giữ các
bản đồ đối tượng ở kích thước hợp lý khi số lượng đối tượng tăng lên và để cho phép các
lớp tích chập tiếp theo “nhìn thấy” phạm vi không gian lớn hơn của đầu vào. Các kết nối
thường được kết thúc bằng thao tác Làm phẳng hoặc lớp tổng hợp toàn cầu, biến bản đồ đặc
trưng không gian thành vectơ, tiếp theo là Lớp dày đặc để đạt được phân loại hoặc hồi quy.
Lưu ý rằng rất có thể các tích chập thông thường sẽ sớm được thay thế phần lớn (hoặc
hoàn toàn) bằng một giải pháp thay thế tương đương nhưng nhanh hơn và hiệu quả hơn về mặt
biểu diễn: tích chập có thể phân tách theo chiều sâu (lớp SeparableConv2D ). Điều này đúng
với đầu vào 3D, 2D và 1D. Khi bạn đang xây dựng một mạng mới từ đầu, sử dụng các kết cấu
có thể tách rời theo chiều sâu chắc chắn là cách tốt nhất. Lớp SeparableConv2D có thể được
sử dụng như một sự thay thế tùy chọn cho Conv2D, dẫn đến một mạng nhỏ hơn, nhanh hơn cũng
hoạt động tốt hơn trong nhiệm vụ của nó.
Đây là một mạng phân loại hình ảnh điển hình (phân loại theo danh mục, trong trường
hợp này):
model.add(layers.SeparableConv2D(32, 3, activation='relu', input_shape=(chiều cao, chiều
rộng, kênh))) model.add(layers.SeparableConv2D(64, 3,
activation= 'relu')) model.add(layers.MaxPooling2D(2))

3, activation='relu')) model.add(layers.MaxPooling2D(2))

3, activation='relu')) model.add(layers.GlobalAveragePooling2D())
model.add(layers.Dense(32, activation='relu'))
model.add(layers.Dense(num_classes, activation='softmax'))
RNNS
Mạng thần kinh hồi quy (RNN) hoạt động bằng cách xử lý chuỗi đầu vào theo từng bước thời
gian và duy trì trạng thái xuyên suốt (trạng thái thường là một vectơ hoặc tập hợp các vectơ:

một điểm trong không gian hình học trạng thái). Chúng nên được ưu tiên sử dụng hơn so với mạng
chuyển đổi 1D trong trường hợp các trình tự trong đó các mẫu quan tâm không bất biến theo sự dịch
chuyển theo thời gian (ví dụ: dữ liệu chuỗi thời gian trong đó quá khứ gần đây quan trọng hơn quá
khứ xa xôi).
Ba lớp RNN có sẵn trong Keras: SimpleRNN, GRU và LSTM. Đối với hầu hết các mục đích thực tế,
bạn nên sử dụng GRU hoặc LSTM. LSTM mạnh hơn trong hai loại nhưng cũng đắt hơn; bạn có thể coi
GRU như một giải pháp thay thế đơn giản hơn, rẻ hơn so với nó.
Để xếp nhiều lớp RNN chồng lên nhau, mỗi lớp trước lớp cuối cùng trong ngăn xếp phải trả về
chuỗi đầy đủ các đầu ra của nó (mỗi bước thời gian đầu vào sẽ tương ứng với một dấu thời gian đầu
ra); nếu bạn không sắp xếp thêm bất kỳ lớp RNN nào , thì thông thường chỉ trả về đầu ra cuối cùng
chứa thông tin về toàn bộ chuỗi.
Sau đây là một lớp RNN duy nhất để phân loại nhị phân các chuỗi vectơ:
model.add(layers.LSTM(32, input_shape=(num_timesteps, num_features)))
model.add(layers.Dense(num_classes, activation='sigmoid'))
50model.compile(optimizer='rmsprop', loss='binary_crossentropy')
Và đây là lớp RNN xếp chồng lên nhau để phân loại nhị phân các chuỗi vectơ:
model.add(layers.LSTM(32, return_sequences=True,
input_shape=(num_timesteps, num_features)))
model.add(layers.LSTM(32, return_sequences=True)) model.add(layers.LSTM(32))
model.add(layers.Dense(num_classes, activation='sigmoid' ))
9.1.7 Không gian của các khả năng
Bạn sẽ xây dựng được gì với deep learning? Hãy nhớ rằng, việc xây dựng các mô hình học sâu giống
như chơi với các viên gạch LEGO : các lớp có thể được ghép lại với nhau để ánh xạ về cơ bản bất
kỳ thứ gì với bất kỳ thứ gì, miễn là bạn có sẵn dữ liệu đào tạo phù hợp và việc ánh xạ có thể đạt
được thông qua phép biến đổi hình học liên tục với độ phức tạp hợp lý . Không gian của các khả
năng là vô hạn. Phần này cung cấp một vài ví dụ để truyền cảm hứng cho bạn suy nghĩ xa hơn các
nhiệm vụ phân loại và hồi quy cơ bản vốn là nguyên liệu truyền thống của máy học.
Tôi đã sắp xếp các ứng dụng được đề xuất của mình theo phương thức đầu vào và đầu ra. Lưu ý
rằng khá nhiều trong số chúng vượt quá giới hạn của những gì có thể—mặc dù một mô hình có thể được
đào tạo về tất cả các nhiệm vụ này, nhưng trong một số trường hợp, một mô hình như vậy có thể sẽ
không khái quát hóa xa dữ liệu đào tạo của nó. Phần 9.2 và 9.3 sẽ đề cập đến cách loại bỏ những
hạn chế này trong tương lai.

Các khái niệm chính trong đánh giá 323
Ánh xạ dữ liệu vectơ sang dữ liệu vectơ
– Dự đoán chăm sóc sức khỏe—Sắp xếp hồ sơ bệnh án của bệnh nhân để dự đoán kết quả của bệnh nhân
– Nhắm mục tiêu theo hành vi—Ánh xạ một tập hợp các thuộc tính của trang web với dữ liệu về khoảng
thời gian người dùng sẽ dành cho trang web
– Kiểm soát chất lượng sản phẩm —Ánh xạ một tập hợp các thuộc tính có liên quan đến một phiên bản
của sản phẩm được sản xuất với xác suất sản phẩm sẽ bị lỗi vào lần tiếp theo
năm
Ánh xạ dữ liệu hình ảnh sang dữ liệu vector
– Trợ lý bác sĩ—Lập bản đồ các slide hình ảnh y tế với dự đoán về sự hiện diện của khối u
– Xe tự lái —Ánh xạ các khung hình video camera hành trình trên ô tô tới các lệnh góc vô lăng
– Board game AI—Lập bản đồ cờ vây và bàn cờ để người chơi tiếp theo di chuyển
– Trợ giúp ăn kiêng —Đánh giá hình ảnh của một món ăn với lượng calo của nó
– Dự đoán tuổi—Ánh xạ ảnh tự chụp với tuổi của người đó Ánh xạ dữ
liệu chuỗi thời gian sang dữ liệu vectơ
– Dự đoán thời tiết—Lập bản đồ chuỗi thời gian của dữ liệu thời tiết trong một lưới các vị trí của
dữ liệu thời tiết vào tuần tiếp theo tại một vị trí cụ thể
– Giao diện não-máy tính—Lập bản đồ chuỗi thời gian của từ não đồ
(MEG) dữ liệu vào lệnh máy tính

– Nhắm mục tiêu theo hành vi—Lập bản đồ chuỗi thời gian tương tác của người dùng trên một trang web với
xác suất người dùng sẽ mua thứ gì đó Ánh xạ văn bản
thành văn bản
– Trả lời thông minh —Ánh xạ email tới các câu trả lời một dòng khả thi
– Trả lời câu hỏi—Sắp xếp câu hỏi kiến thức tổng quát thành câu trả lời
– Tóm tắt—Ánh xạ một bài viết dài thành một bản tóm tắt ngắn của bài báo
Ánh xạ hình ảnh vào văn bản
– Chú thích—Ánh xạ hình ảnh thành chú thích ngắn mô tả nội dung của
hình ảnh
Ánh xạ văn bản vào hình ảnh
– Tạo hình ảnh có điều kiện—Ánh xạ mô tả văn bản ngắn thành hình ảnh phù hợp với mô tả
– Tạo /lựa chọn logo—Kết hợp tên và mô tả của một công ty với logo của công ty Kết nối hình ảnh
với hình ảnh
– Siêu phân giải—Ánh xạ các hình ảnh đã thu nhỏ thành các phiên bản có độ phân giải cao hơn của
cùng một hình ảnh
– Cảm biến độ sâu trực quan —Ánh xạ hình ảnh của môi trường trong nhà thành bản đồ dự đoán độ sâu

Ánh xạ hình ảnh và văn bản thành văn bản
– Visual QA—Lập bản đồ hình ảnh và các câu hỏi bằng ngôn ngữ tự nhiên về kẻ lừa đảo
lều hình ảnh cho câu trả lời bằng ngôn ngữ tự nhiên
Ánh xạ video và văn bản thành văn bản
– Video QA—Lập bản đồ các video ngắn và các câu hỏi bằng ngôn ngữ tự nhiên về
nội dung của video cho câu trả lời bằng ngôn ngữ tự nhiên
Hầu hết mọi thứ đều có thể - nhưng không hoàn toàn là mọi thứ. Hãy xem trong phần tiếp theo chúng ta
không thể làm gì với deep learning.

Hạn chế của học sâu 325
9.2 Hạn chế của học sâu

Không gian của các ứng dụng có thể được triển khai với học sâu là gần như vô hạn. Chưa hết,
nhiều ứng dụng hoàn toàn nằm ngoài tầm với của các kỹ thuật học sâu hiện tại—thậm chí với một
lượng lớn dữ liệu do con người chú thích. Chẳng hạn, giả sử bạn có thể tập hợp một bộ dữ liệu
gồm hàng trăm nghìn—thậm chí hàng triệu—mô tả bằng tiếng Anh về các tính năng của một sản phẩm
phần mềm, được viết bởi người quản lý sản phẩm, cũng như mã nguồn tương ứng được phát triển
bởi một nhóm của các kỹ sư để đáp ứng các yêu cầu này. Ngay cả với dữ liệu này, bạn không thể
đào tạo một mô hình học sâu để đọc mô tả sản phẩm và tạo cơ sở mã phù hợp. Đó chỉ là một ví dụ
trong số rất nhiều. Nói chung, bất cứ điều gì đòi hỏi phải suy luận—như lập trình hoặc áp dụng
phương pháp khoa học—lập kế hoạch dài hạn và thao tác dữ liệu theo thuật toán đều nằm ngoài
tầm với của các mô hình học sâu, bất kể bạn ném bao nhiêu dữ liệu vào chúng. Ngay cả việc học
một thuật toán sắp xếp với mạng lưới thần kinh sâu cũng cực kỳ khó khăn.
Điều này là do mô hình học sâu chỉ là một chuỗi các phép biến đổi hình học liên tục, đơn
giản ánh xạ không gian vectơ này sang không gian vectơ khác. Tất cả những gì nó có thể làm là
ánh xạ một đa tạp dữ liệu X vào một đa tạp Y khác, giả sử sự tồn tại của một phép biến đổi
liên tục có thể học được từ X sang Y. Một mô hình học sâu có thể được hiểu là một loại chương
trình; nhưng ngược lại, hầu hết các chương trình không thể được biểu diễn dưới dạng các mô
hình học sâu—đối với hầu hết các nhiệm vụ, hoặc là không tồn tại mạng lưới thần kinh sâu tương
ứng để giải quyết nhiệm vụ hoặc, ngay cả khi có tồn tại, nó có thể không học được: hình học
tương ứng biến đổi có thể quá phức tạp hoặc có thể không có sẵn dữ liệu phù hợp để tìm hiểu nó.
Mở rộng quy mô các kỹ thuật học sâu hiện tại bằng cách xếp chồng nhiều lớp hơn và sử dụng
nhiều dữ liệu đào tạo hơn chỉ có thể làm giảm nhẹ một số vấn đề này. Nó sẽ không giải quyết
được các vấn đề cơ bản hơn mà các mô hình học sâu bị hạn chế về những gì chúng có thể biểu
diễn và hầu hết các chương trình bạn muốn học không thể được biểu thị dưới dạng biến đổi hình
học liên tục của đa tạp dữ liệu.
9.2.1 Nguy cơ nhân hóa các mô hình học máy

Một rủi ro thực sự với AI hiện đại là hiểu sai chức năng của các mô hình học sâu và đánh giá
quá cao khả năng của chúng. Một đặc điểm cơ bản của con người là lý thuyết về tâm trí của chúng
ta: xu hướng phóng chiếu ý định, niềm tin và kiến thức của chúng ta về những thứ xung quanh
chúng ta. Vẽ một khuôn mặt cười trên đá đột nhiên khiến nó trở nên “hạnh phúc”—trong tâm trí
chúng ta. Áp dụng cho học sâu, điều này có nghĩa là, chẳng hạn, khi chúng ta có thể thành công
phần nào trong việc huấn luyện đầy đủ một mô hình để tạo chú thích mô tả ảnh, chúng ta sẽ tin
rằng mô hình đó “hiểu” nội dung của ảnh và chú thích mà nó tạo ra.
Sau đó, chúng tôi ngạc nhiên khi bất kỳ sai lệch nhỏ nào so với loại hình ảnh có trong dữ liệu
đào tạo đều khiến mô hình tạo ra các chú thích hoàn toàn vô lý (xem hình 9.1).

Hình 9.1 Lỗi hệ thống phụ đề hình ảnh dựa trên

học sâu
Cậu bé đang cầm một cây gậy bóng chày.
Đặc biệt, điều này được làm nổi bật bởi các ví dụ đối nghịch, là các mẫu được cung cấp
cho mạng học sâu được thiết kế để đánh lừa mô hình phân loại sai chúng.
Bạn đã biết rằng, chẳng hạn, có thể thực hiện tăng dần độ dốc trong không gian đầu vào
để tạo đầu vào tối đa hóa việc kích hoạt một số bộ lọc convnet—đây là cơ sở của kỹ thuật
trực quan hóa bộ lọc được giới thiệu trong chương 5, cũng như thuật toán DeepDream trong
chương 8. Tương tự như vậy, thông qua độ dốc tăng dần, bạn có thể sửa đổi một chút hình
ảnh để tối đa hóa dự đoán lớp cho một lớp nhất định. Bằng cách chụp ảnh một con gấu trúc
và thêm vào đó một dải màu vượn, chúng ta có thể có được một mạng lưới thần kinh để phân
loại gấu trúc thành một con vượn (xem hình 9.2). Điều này chứng minh cả tính dễ vỡ của
các mô hình này và sự khác biệt sâu sắc giữa ping bản đồ đầu vào-đầu ra của chúng và
nhận thức của con người chúng ta.
f(x) f(x)
gấu trúc Con vượn!

Độ dốc
lớp vượn
gấu trúc ví dụ về đối thủ
Hình 9.2 Một ví dụ đối lập: những thay đổi không thể nhận thấy trong một hình ảnh có
thể thay đổi sự phân loại hình ảnh của một mô hình.

Nói tóm lại, các mô hình học sâu không có bất kỳ hiểu biết nào về đầu vào của chúng — ít nhất, không phải
theo nghĩa của con người. Sự hiểu biết của chúng ta về hình ảnh, âm thanh và ngôn ngữ dựa trên trải nghiệm
cảm biến vận động của chúng ta với tư cách là con người. Các mô hình học máy không có quyền truy cập vào
những trải nghiệm như vậy và do đó không thể hiểu đầu vào của chúng theo cách có thể tin được của con
người. Bằng cách chú thích một số lượng lớn các ví dụ đào tạo để đưa vào các mô hình của chúng tôi, chúng
tôi giúp họ học một phép biến đổi hình học ánh xạ dữ liệu tới các khái niệm của con người trên một tập hợp
các ví dụ cụ thể, nhưng ánh xạ này là một bản phác thảo đơn giản của mô hình ban đầu trong tâm trí của
chúng tôi— cái được phát triển từ kinh nghiệm của chúng tôi với tư cách là tác nhân hiện thân. Nó giống
như một hình ảnh mờ trong gương (xem hình 9.3).
Dữ liệu được dán
Kinh nghiệm Khái niệm trừu tượng nhãn minh họa Mô hình học máy
Thế giới thực hiện thân của con người trong tâm trí con người cho các khái niệm này
f(x)
Có thể không phải lúc Không phù hợp với mô Phù hợp với dữ
nào cũng chuyển tốt hình tinh thần của con người liệu huấn luyện
sang thế giới thực nó đến từ
Hình 9.3 Các mô hình học máy hiện tại: giống như một hình ảnh mờ trong gương
Là một người thực hành máy học, hãy luôn lưu tâm đến điều này và đừng bao giờ rơi vào cái bẫy tin rằng các
mạng nơ-ron hiểu nhiệm vụ mà chúng thực hiện—chúng không hiểu, ít nhất là không theo cách có ý nghĩa đối
với chúng ta. Họ được đào tạo về một nhiệm vụ khác, hẹp hơn nhiều so với nhiệm vụ mà chúng tôi muốn dạy
họ: đó là ánh xạ đầu vào đào tạo tới các mục tiêu đào tạo, từng điểm một. Cho họ thấy bất cứ thứ gì sai
lệch so với dữ liệu đào tạo của họ, và họ sẽ vi phạm theo những cách vô lý.
9.2.2 Tổng quát hóa cục bộ và tổng quát hóa cực trị
Có những khác biệt cơ bản giữa việc biến đổi hình học đơn giản từ đầu vào sang đầu ra mà các mô hình học
sâu thực hiện và cách con người suy nghĩ và học hỏi. Thực tế không chỉ là con người tự học hỏi từ kinh
nghiệm hiện thân thay vì được cung cấp các ví dụ đào tạo rõ ràng. Ngoài các quá trình học tập khác nhau,
có một sự khác biệt cơ bản trong bản chất của các biểu diễn cơ bản.
Con người có khả năng làm được nhiều việc hơn là lập bản đồ các kích thích tức thời thành các phản ứng
tức thời, giống như một mạng lưới sâu, hoặc có thể là một con côn trùng. Chúng tôi duy trì các mô hình trừu
tượng , phức tạp về tình hình hiện tại của chúng tôi, của chính chúng tôi và của những người khác và có
thể sử dụng các mô hình này để dự đoán các tương lai khác nhau có thể xảy ra và thực hiện kế hoạch dài hạn.
Chúng ta có thể hợp nhất các khái niệm đã biết để đại diện cho điều gì đó mà chúng ta chưa từng trải nghiệm

trước đây—chẳng hạn như hình dung một con ngựa mặc quần jean, hoặc tưởng tượng chúng ta sẽ làm gì nếu
trúng xổ số. Khả năng này để xử lý các giả thuyết, để mở rộng không gian mô hình tinh thần của chúng
ta vượt xa những gì chúng ta có thể trải nghiệm trực tiếp—để thực hiện sự trừu tượng hóa và lập luận
—được cho là đặc điểm xác định nhận thức của con người. Tôi gọi đó là sự tổng quát hóa cực độ: khả
năng thích ứng với những tình huống mới lạ, chưa từng có trước đây khi sử dụng ít dữ liệu hoặc thậm
chí không có dữ liệu mới nào.
Điều này trái ngược hoàn toàn với những gì deep net làm, mà tôi gọi là khái quát hóa cục bộ (xem
hình 9.4). Quá trình ánh xạ từ đầu vào đến đầu ra được thực hiện bởi một mạng sâu sẽ nhanh chóng
không còn ý nghĩa nếu đầu vào mới thậm chí khác một chút so với những gì mà mạng nhìn thấy tại thời
điểm huấn luyện. Ví dụ, hãy xem xét vấn đề tìm hiểu các tham số phóng thích hợp để đưa một tên lửa
đáp xuống mặt trăng. Nếu bạn sử dụng mạng sâu cho nhiệm vụ này và đào tạo nó bằng cách học có giám
sát hoặc học tăng cường, bạn sẽ phải cung cấp cho nó hàng nghìn hoặc thậm chí hàng triệu lần thử
nghiệm khởi chạy: bạn cần đưa nó vào một không gian đầu vào lấy mẫu dày đặc , để nó học một ánh xạ
đáng tin cậy từ không gian đầu vào sang không gian đầu ra. Ngược lại, là con người, chúng ta có thể
sử dụng sức mạnh trừu tượng của mình để nghĩ ra các mô hình vật lý—khoa học tên lửa—và rút ra một giải
pháp chính xác sẽ hạ cánh tên lửa lên mặt trăng.
trong một hoặc một vài thử nghiệm. Tương tự, nếu bạn phát triển một mạng lưới sâu kiểm soát cơ thể
người và bạn muốn nó học cách di chuyển an toàn trong thành phố mà không bị ô tô đâm, thì mạng lưới
đó sẽ phải chết hàng nghìn lần trong các tình huống khác nhau cho đến khi nó có thể suy luận rằng ô
tô là nguy hiểm và phát triển các hành vi tránh thích hợp. Rơi vào một thành phố mới, mạng sẽ phải
học lại hầu hết những gì nó biết. Mặt khác, con người có thể học các hành vi an toàn mà không phải
chết dù chỉ một lần—nhờ khả năng lập mô hình trừu tượng của chúng ta về các tình huống giả định.
cùng một bộ
điểm dữ liệu
hoặc kinh nghiệm
Tổng quát hóa cục bộ: Khái quát hóa cực độ: sức
sức mạnh tổng quát hóa mạnh khái quát hóa đạt
Hình 9.4 Tổng quát hóa cục bộ và
của nhận dạng mẫu được thông qua trừu tượng
tổng quát hóa cực trị
hóa và lý luận
Nói tóm lại, bất chấp những tiến bộ của chúng ta về nhận thức máy móc, chúng ta vẫn còn cách xa AI ở
cấp độ con người. Các mô hình của chúng tôi chỉ có thể thực hiện khái quát hóa cục bộ, thích ứng với
các tình huống mới phải giống với dữ liệu trong quá khứ, trong khi nhận thức của con người có khả năng

khái quát hóa cực độ, nhanh chóng thích ứng với các tình huống hoàn toàn mới lạ và lập kế hoạch cho
các tình huống trong tương lai dài hạn.
9.2.3 Kết thúc

Đây là những gì bạn nên nhớ: thành công thực sự duy nhất của học sâu cho đến nay là khả năng ánh
xạ không gian X sang không gian Y bằng cách sử dụng phép biến đổi hình học liên tục, dựa trên
lượng lớn dữ liệu do con người chú thích. Làm tốt điều này là yếu tố thay đổi cuộc chơi về cơ bản
cho mọi ngành, nhưng vẫn còn một chặng đường dài để đạt được AI ở cấp độ con người.
Để loại bỏ một số hạn chế mà chúng ta đã thảo luận và tạo ra AI có thể cạnh tranh với bộ não con
người, chúng ta cần chuyển từ ping bản đồ đầu vào sang đầu ra đơn giản và chuyển sang suy luận và
trừu tượng hóa. Một chất nền có khả năng thích hợp để mô hình hóa trừu tượng các tình huống và khái
niệm khác nhau là chất nền của các chương trình máy tính. Chúng tôi đã nói trước đây rằng các mô hình
học máy có thể được định nghĩa là các chương trình có thể học được; hiện tại chúng ta chỉ có thể học
các chương trình thuộc về một tập hợp con hẹp và cụ thể của tất cả các chương trình có thể. Nhưng nếu
chúng ta có thể học bất kỳ chương trình nào, theo cách mô-đun và có thể tái sử dụng thì sao? Hãy xem
trong phần tiếp theo con đường phía trước sẽ như thế nào.

9.3 Tương lai của học sâu

Đây là một phần mang tính suy đoán hơn nhằm mở ra chân trời cho những người muốn tham gia một chương trình nghiên
cứu hoặc bắt đầu thực hiện nghiên cứu độc lập. Với những gì chúng ta biết về cách thức hoạt động của deep net,
những hạn chế của chúng và tình trạng hiện tại của bối cảnh nghiên cứu, chúng ta có thể dự đoán mọi thứ sẽ đi về
đâu trong trung hạn không? Sau đây là một số suy nghĩ hoàn toàn cá nhân. Lưu ý rằng tôi không có quả cầu pha lê,
vì vậy rất nhiều điều tôi dự đoán có thể không thành hiện thực. Tôi đang chia sẻ những dự đoán này không phải vì
tôi hy vọng chúng sẽ được chứng minh là hoàn toàn đúng trong tương lai, mà bởi vì chúng thú vị và có thể hành
động trong hiện tại.
Ở cấp độ cao, đây là những hướng chính mà tôi thấy hứa hẹn: Các mô hình gần với các
chương trình máy tính có mục đích chung, được xây dựng trên nền tảng nguyên thủy phong phú hơn nhiều so với
các lớp khả vi hiện tại. Đây là cách chúng ta sẽ đi đến lý luận và trừu tượng hóa, thiếu chúng là điểm
yếu cơ bản của các mô hình hiện tại. Các hình thức học tập mới làm cho điểm trước đó trở nên khả thi,
cho phép các mô hình tránh xa các phép biến đổi khả vi. Các mô hình yêu cầu ít sự tham gia của các kỹ sư
con người hơn. Nó không phải là công việc của bạn để
nút điều chỉnh vô tận.
Sử dụng lại nhiều hơn, có hệ thống hơn các tính năng và kiến trúc đã học trước đó, chẳng hạn như các hệ
thống siêu học tập sử dụng các chương trình con chương trình mô-đun và có thể tái sử dụng.
Ngoài ra, hãy lưu ý rằng những cân nhắc này không dành riêng cho loại học có giám sát vốn là cốt lõi của học sâu
cho đến nay—thay vào đó, chúng có thể áp dụng cho mọi hình thức học máy, bao gồm học không giám sát, tự giám sát
và học tăng cường. Về cơ bản, điều quan trọng không phải là nhãn của bạn đến từ đâu hoặc vòng lặp đào tạo của bạn
trông như thế nào; các nhánh khác nhau của máy học là các khía cạnh khác nhau của cùng một cấu trúc. Hãy đi sâu
vào.
9.3.1 Mô hình dưới dạng chương trình
Như đã lưu ý trong phần trước, sự phát triển mang tính chuyển đổi cần thiết mà chúng ta có thể mong đợi trong
lĩnh vực học máy là chuyển từ các mô hình thực hiện nhận dạng mẫu đơn thuần và chỉ có thể đạt được sự khái quát
hóa cục bộ, hướng tới các mô hình có khả năng trừu tượng hóa và lập luận có thể đạt được khái quát hóa cực đoan.
Các chương trình AI hiện tại có khả năng lập luận ở dạng cơ bản đều được mã hóa cứng bởi các lập trình viên con
người: ví dụ: phần mềm dựa trên thuật toán tìm kiếm, thao tác đồ thị và logic hình thức. Ví dụ, trong AlphaGo của
DeepMind, hầu hết trí thông minh hiển thị được thiết kế và mã hóa cứng bởi các lập trình viên chuyên nghiệp
(chẳng hạn như Tìm kiếm cây Monte Carlo); học từ dữ liệu chỉ xảy ra trong các mô-đun con chuyên biệt (mạng giá
trị hoạt động và mạng chính sách). Nhưng trong tương lai, những hệ thống AI như vậy có thể được học hoàn toàn mà
không cần sự tham gia của con người.
Con đường nào có thể làm cho điều này xảy ra? Hãy xem xét một loại mạng nổi tiếng: RNNs.
Điều quan trọng cần lưu ý là RNN có ít hạn chế hơn một chút so với mạng feedforward hoạt động. Đó là bởi vì RNN
không chỉ là các phép biến đổi hình học đơn thuần:

Tương lai của học sâu 331
chúng là các phép biến đổi hình học được áp dụng lặp đi lặp lại bên trong vòng lặp for . Bản
thân vòng lặp for tạm thời đã được mã hóa cứng bởi các nhà phát triển con người: đó là một giả
định tích hợp sẵn của công việc mạng. Đương nhiên, RNN vẫn còn rất hạn chế về những gì chúng có
thể biểu diễn, chủ yếu là do mỗi bước chúng thực hiện là một phép biến đổi hình học khả vi và
chúng mang thông tin từ bước này sang bước khác qua các điểm trong không gian hình học liên tục
(vectơ trạng thái). Bây giờ hãy tưởng tượng một mạng thần kinh được tăng cường theo cách tương
tự với các nguyên mẫu lập trình—nhưng thay vì một vòng lặp for được mã hóa cứng duy nhất với bộ
nhớ hình học được mã hóa cứng, mạng bao gồm một tập hợp lớn các nguyên mẫu lập trình mà mô hình
có thể tự do thao tác để mở rộng chức năng xử lý của nó , chẳng hạn như các nhánh if , câu lệnh
while , tạo biến, lưu trữ đĩa cho bộ nhớ dài hạn, toán tử sắp xếp, cấu trúc dữ liệu nâng cao
(chẳng hạn như danh sách, đồ thị và bảng băm), v.v. Không gian của các chương trình mà một mạng
như vậy có thể đại diện sẽ rộng hơn nhiều so với những gì có thể được thể hiện bằng các mô hình
học sâu hiện tại và một số chương trình này có thể đạt được sức mạnh tổng quát hóa vượt trội.
Một mặt, chúng ta sẽ tránh xa việc có trí thông minh thuật toán được mã hóa cứng (phần mềm
thủ công) và mặt khác, trí thông minh hình học đã học (học sâu). Thay vào đó, chúng ta sẽ có sự
kết hợp của các mô-đun thuật toán chính thức cung cấp các khả năng suy luận và trừu tượng hóa
cũng như các mô-đun hình học cung cấp các khả năng nhận dạng mẫu và trực giác không chính thức.
Toàn bộ hệ thống sẽ được học với rất ít hoặc không có sự tham gia của con người.
Một lĩnh vực con liên quan của AI mà tôi nghĩ có thể sắp phát triển vượt bậc là tổng hợp
chương trình, cụ thể là tổng hợp chương trình thần kinh. Tổng hợp chương trình bao gồm tự động
tạo ra các chương trình đơn giản bằng cách sử dụng thuật toán tìm kiếm (có thể là tìm kiếm di
truyền, như trong lập trình di truyền) để khám phá một không gian rộng lớn của các chương trình có thể.
Quá trình tìm kiếm dừng lại khi tìm thấy một chương trình phù hợp với các thông số kỹ thuật được
yêu cầu, thường được cung cấp dưới dạng một tập hợp các cặp đầu vào-đầu ra. Điều này rất gợi nhớ
đến học máy: dữ liệu đào tạo được cung cấp dưới dạng các cặp đầu vào-đầu ra, chúng tôi tìm thấy
một chương trình khớp đầu vào với đầu ra và có thể khái quát hóa thành đầu vào mới. Sự khác biệt
là thay vì học các giá trị tham số trong chương trình được mã hóa cứng (mạng nơ-ron), chúng tôi
tạo mã nguồn thông qua quy trình tìm kiếm rời rạc.
Tôi chắc chắn mong đợi lĩnh vực con này sẽ chứng kiến một làn sóng quan tâm mới trong vài
năm tới. Đặc biệt, tôi mong đợi sự xuất hiện của một trường con chéo giữa học sâu và tổng hợp
chương trình, trong đó thay vì tạo chương trình bằng ngôn ngữ có mục đích chung, chúng tôi sẽ
tạo ra các mạng thần kinh (luồng xử lý dữ liệu hình học) được tăng cường bằng một tập hợp thuật
toán nguyên thủy phong phú , chẳng hạn như vòng lặp for và nhiều vòng lặp khác (xem hình 9.5).
Điều này sẽ dễ thực hiện và hữu ích hơn nhiều so với việc tạo mã nguồn trực tiếp và nó sẽ mở
rộng đáng kể phạm vi các vấn đề có thể giải quyết bằng máy học—không gian của các chương trình
mà chúng ta có thể tạo tự động, được cung cấp dữ liệu đào tạo phù hợp. Các RNN đương đại có thể
được coi là tổ tiên tiền sử của các mô hình hình học-thuật toán kết hợp như vậy.

Chương trình cấp nhiệm vụ mô-đun
được học nhanh chóng để giải quyết

Dữ liệu và
một nhiệm vụ cụ thể
phản hồi
chương trình chương trình Nhiệm vụ #002456

con hình học con thuật toán Hình 9.5 Một chương trình đã học dựa
hành động
trên cả nguyên hàm hình học (nhận dạng
chương trình chương trình mẫu, trực giác) và nguyên hàm thuật toán
con hình học con thuật toán
(suy luận, tìm kiếm, ghi nhớ)
9.3.2 Ngoài lan truyền ngược và các lớp khả vi
Nếu các mô hình học máy trở nên giống các chương trình hơn, thì hầu như chúng sẽ không còn khả
năng phân biệt nữa—các chương trình này sẽ vẫn sử dụng các lớp hình học liên tục làm các quy
trình phụ, điều này sẽ có thể phân biệt được, nhưng toàn bộ mô hình sẽ không như vậy. Kết quả là,
sử dụng lan truyền ngược để điều chỉnh các giá trị trọng số trong một mạng cố định, được mã hóa
cứng không thể là phương pháp được lựa chọn cho các mô hình đào tạo trong tương lai—ít nhất, đó
không thể là toàn bộ câu chuyện. Chúng ta cần tìm ra cách đào tạo các hệ thống không thể phân
biệt một cách hiệu quả. Các phương pháp tiếp cận hiện tại bao gồm các thuật toán di truyền, chiến
lược tiến hóa, một số phương pháp học tập củng cố nhất định và phương pháp nhân số định hướng xen kẽ (ADMM).
Đương nhiên, giảm dần độ dốc sẽ không đi đâu cả; thông tin về độ dốc sẽ luôn hữu ích để tối ưu hóa các hàm
tham số khả vi. Nhưng các mô hình của chúng tôi sẽ ngày càng trở nên tham vọng hơn so với các hàm tham số
có thể phân biệt đơn thuần, và do đó, sự phát triển tự động của chúng (việc học trong máy học) sẽ đòi hỏi
nhiều hơn là lan truyền ngược.
Ngoài ra, lan truyền ngược là end-to-end, đây là một điều tuyệt vời để học các phép biến đổi chuỗi tốt
nhưng không hiệu quả về mặt tính toán vì nó không tận dụng được hết tính mô đun của các mạng sâu. Để tạo
ra thứ gì đó hiệu quả hơn, có một công thức chung: giới thiệu tính mô đun và hệ thống phân cấp. Vì vậy,
chúng tôi có thể làm cho việc lan truyền ngược trở nên hiệu quả hơn bằng cách giới thiệu các mô-đun đào tạo
tách rời với cơ chế đồng bộ hóa giữa chúng, được tổ chức theo kiểu phân cấp.
Chiến lược này phần nào được phản ánh trong công trình gần đây của DeepMind về độ dốc tổng hợp.
Tôi mong đợi nhiều hơn dọc theo những dòng này trong tương lai gần. Tôi có thể tưởng tượng một tương lai
nơi các mô hình không thể phân biệt được trên toàn cầu (nhưng có các phần có thể phân biệt được) được đào
tạo—được phát triển—bằng cách sử dụng quy trình tìm kiếm hiệu quả không sử dụng độ dốc, trong khi các phần
có thể phân biệt được đào tạo thậm chí còn nhanh hơn bằng cách tận dụng lợi thế của chuyển màu bằng cách
sử dụng phiên bản lan truyền ngược hiệu quả hơn.
9.3.3 Học máy tự động
Trong tương lai, kiến trúc mô hình sẽ được học thay vì được làm thủ công bởi các nghệ nhân mới. Kiến trúc
học tập đi đôi với việc sử dụng các tập nguyên thủy phong phú hơn và các mô hình học máy giống như chương
trình.

Hiện tại, hầu hết công việc của một kỹ sư học sâu bao gồm trộn dữ liệu với các tập lệnh
Python, sau đó điều chỉnh kiến trúc và siêu tham số của một mạng sâu để có được một mô hình
hoạt động — hoặc thậm chí để có được một mô hình hiện đại nhất. mô hình, nếu kỹ sư là tham
vọng đó. Không cần phải nói, đó không phải là một thiết lập tối ưu. Nhưng AI có thể giúp.
Thật không may, phần trộn dữ liệu rất khó để tự động hóa, bởi vì nó thường đòi hỏi kiến thức
về miền cũng như sự hiểu biết rõ ràng, ở mức độ cao về những gì kỹ sư muốn đạt được. Tuy
nhiên, điều chỉnh siêu tham số là một quy trình tìm kiếm đơn giản; và trong trường hợp đó,
chúng tôi biết kỹ sư muốn đạt được điều gì: nó được xác định bởi hàm mất mát của mạng được
điều chỉnh. Việc thiết lập các hệ thống AutoML cơ bản đảm nhận hầu hết việc điều chỉnh núm
mô hình đã trở nên phổ biến. Nhiều năm trước, tôi thậm chí còn thành lập riêng mình để giành
chiến thắng trong các cuộc thi Kaggle.
Ở cấp độ cơ bản nhất, một hệ thống như vậy sẽ điều chỉnh số lượng lớp trong ngăn xếp,
thứ tự của chúng và số lượng đơn vị hoặc bộ lọc trong mỗi lớp. Điều này thường được thực
hiện với các thư viện như Hyperopt, mà chúng ta đã thảo luận trong chương 7. Nhưng chúng ta
cũng có thể tham vọng hơn nhiều và cố gắng học một kiến trúc thích hợp từ đầu, với càng ít
ràng buộc càng tốt: ví dụ, thông qua học tăng cường hoặc di truyền. thuật toán.
Một hướng AutoML quan trọng khác liên quan đến việc học kiến trúc mô hình cùng với trọng
số mô hình. Bởi vì việc đào tạo một mô hình mới từ đầu mỗi khi chúng tôi thử một kiến trúc
hơi khác là cực kỳ kém hiệu quả, nên một hệ thống AutoML thực sự mạnh mẽ sẽ phát triển các
kiến trúc đồng thời các tính năng của mô hình được điều chỉnh thông qua lan truyền ngược
trên dữ liệu đào tạo. Những cách tiếp cận như vậy đang bắt đầu xuất hiện khi tôi viết những
dòng này.
Khi điều này bắt đầu xảy ra, công việc của các kỹ sư máy học sẽ không biến mất—đúng hơn,
các kỹ sư sẽ tiến lên trong chuỗi tạo giá trị. Họ sẽ bắt đầu nỗ lực nhiều hơn nữa để tạo ra
các hàm tổn thất phức tạp phản ánh thực sự các mục tiêu kinh doanh và hiểu cách các mô hình
của họ tác động đến hệ sinh thái kỹ thuật số mà chúng được triển khai (ví dụ: người dùng sử
dụng dự đoán của mô hình và tạo dữ liệu đào tạo của mô hình )—những vấn đề mà hiện nay chỉ
những công ty lớn nhất mới đủ khả năng xem xét.
9.3.4 Học tập suốt đời và tái sử dụng chương trình con mô đun
Nếu các mô hình trở nên phức tạp hơn và được xây dựng dựa trên các thuật toán gốc phong phú
hơn, thì độ phức tạp gia tăng này sẽ yêu cầu khả năng tái sử dụng cao hơn giữa các tác vụ,
thay vì đào tạo một mô hình mới từ đầu mỗi khi chúng ta có một tác vụ mới hoặc tập dữ liệu mới.
Nhiều bộ dữ liệu không chứa đủ thông tin để chúng tôi phát triển một mô hình mới, phức tạp
từ đầu và sẽ cần phải sử dụng thông tin từ các bộ dữ liệu đã gặp trước đó (giống như bạn
không học tiếng Anh từ đầu mỗi khi mở một cuốn sách mới —điều đó là không thể). Các mô hình
đào tạo từ đầu cho mọi nhiệm vụ mới cũng không hiệu quả do sự chồng chéo lớn giữa các nhiệm
vụ hiện tại và các nhiệm vụ đã gặp phải trước đó.

Một quan sát đáng chú ý đã được thực hiện nhiều lần trong những năm gần đây: đào tạo cùng một mô hình
để thực hiện một số nhiệm vụ được kết nối lỏng lẻo cùng một lúc dẫn đến một mô hình tốt hơn ở mỗi nhiệm
vụ. Chẳng hạn, đào tạo cùng một mô hình dịch máy thần kinh để thực hiện cả dịch từ tiếng Anh sang tiếng
Đức và từ tiếng Pháp sang tiếng Ý sẽ dẫn đến một mô hình tốt hơn ở mỗi cặp ngôn ngữ. Tương tự như vậy,
huấn luyện một mô hình phân loại hình ảnh cùng với một mô hình phân đoạn hình ảnh, chia sẻ cùng một cơ sở
tích chập, dẫn đến một mô hình tốt hơn ở cả hai nhiệm vụ. Điều này khá trực quan: luôn có một số thông
tin chồng chéo giữa các nhiệm vụ dường như bị ngắt kết nối và một mô hình chung có quyền truy cập vào
lượng thông tin lớn hơn về từng nhiệm vụ riêng lẻ so với một mô hình chỉ được đào tạo về nhiệm vụ cụ thể
đó.
Hiện tại, khi đề cập đến việc sử dụng lại mô hình trong các tác vụ, chúng tôi sử dụng các trọng số
được huấn luyện trước cho các mô hình thực hiện các chức năng phổ biến, chẳng hạn như trích xuất đặc điểm
trực quan. Bạn đã thấy điều này thực tế trong chương 5. Trong tương lai, tôi hy vọng một phiên bản tổng
quát của điều này sẽ trở nên phổ biến: chúng ta sẽ không chỉ sử dụng các tính năng đã học trước đó (trọng
số mô hình con) mà còn cả kiến trúc mô hình và quy trình đào tạo. Khi các mô hình trở nên giống pro gram
hơn, chúng ta sẽ bắt đầu sử dụng lại các chương trình con của chương trình như các hàm và lớp được tìm
thấy trong các ngôn ngữ lập trình của con người.
Hãy nghĩ về quy trình phát triển phần mềm ngày nay: một khi một kỹ sư giải quyết được một vấn đề cụ
thể (ví dụ: truy vấn HTTP bằng Python), họ đóng gói nó dưới dạng một thư viện trừu tượng, có thể tái sử
dụng. Các kỹ sư gặp phải vấn đề tương tự trong tương lai sẽ có thể tìm kiếm các thư viện hiện có, tải
xuống một thư viện và sử dụng nó trong dự án của riêng họ. Theo cách tương tự, trong tương lai, các hệ
thống siêu học tập sẽ có thể lắp ráp các chương trình mới bằng cách sàng lọc thông qua một thư viện toàn
cầu gồm các khối có thể tái sử dụng cấp cao. Khi hệ thống thấy mình đang phát triển các chương trình con
tương tự cho một số nhiệm vụ khác nhau, nó có thể đưa ra một phiên bản trừu tượng, có thể tái sử dụng của
chương trình con và lưu trữ nó trong thư viện chung (xem hình 9.6). Một quy trình như vậy sẽ thực hiện
trừu tượng hóa: một thành phần cần thiết để đạt được sự khái quát hóa cực độ. Một chương trình con hữu
ích trong các nhiệm vụ và lĩnh vực khác nhau có thể được cho là trừu tượng hóa một số khía cạnh của việc
giải quyết vấn đề. Định nghĩa trừu tượng hóa này tương tự như khái niệm trừu tượng hóa trong công nghệ
phần mềm. Các quy trình phụ này có thể là hình học (các mô-đun học sâu với các biểu diễn được đào tạo
trước) hoặc thuật toán (gần với các thư viện mà các kỹ sư phần mềm hiện đại thao tác).

Thư viện toàn cầu của

Đẩy
các chương trình con trừu tượng
các chương
trình con tái sử dụng

Người học meta vĩnh viễn có khả
chương trình chương trình chương trình
con hình học con thuật toán con thuật toán năng phát triển nhanh mô hình cấp
nhiệm vụ trên nhiều nhiệm vụ
chương trình chương trình chương trình

Tìm nạp khác nhau
Nhiệm vụ #002453
con hình học con thuật toán con thuật toán
các chương
chương trình chương trình chương trình trình con có liên quan
con hình học con thuật toán con thuật toán Nhiệm vụ #002454
lựa chọn Dữ liệu và
thiết kế phản hồi
Nhiệm vụ #002455
Chương trình cấp nhiệm vụ mô-đun được
học nhanh chóng để giải quyết một

Dữ liệu và
nhiệm vụ cụ thể
phản hồi
chương trình chương trình con Nhiệm vụ #002456

con hình học thuật toán
hành động
chương trình chương trình con

con hình học thuật toán
Hình 9.6 Một siêu học viên có khả năng phát triển nhanh chóng các mô hình dành riêng cho nhiệm vụ bằng cách sử dụng các nguyên
mẫu có thể tái sử dụng (cả về thuật toán và hình học), do đó đạt được sự khái quát hóa cực cao
9.3.5 Tầm nhìn dài hạn
Tóm lại, đây là tầm nhìn dài hạn của tôi đối với máy học:
Các mô hình sẽ giống các chương trình hơn và sẽ có các khả năng vượt xa các phép biến đổi
hình học liên tục của dữ liệu đầu vào mà chúng ta hiện đang làm việc. Các chương trình này
được cho là sẽ gần gũi hơn nhiều với các mô hình tinh thần trừu tượng mà con người duy trì
về môi trường xung quanh và bản thân họ, đồng thời chúng sẽ có khả năng khái quát hóa mạnh
mẽ hơn do bản chất thuật toán phong phú của chúng. Đặc biệt, các mô hình sẽ kết hợp các mô-
đun thuật toán cung cấp các khả năng lý luận, tìm kiếm và trừu tượng hóa chính thức với các mô-
đun hình học cung cấp các khả năng trực giác và nhận dạng mẫu không chính thức. AlphaGo (một
hệ thống đòi hỏi nhiều công nghệ phần mềm thủ công và các quyết định thiết kế do con người
tạo ra) cung cấp một ví dụ ban đầu về sự kết hợp giữa AI hình học và biểu tượng như vậy có
thể trông như thế nào.
Các mô hình như vậy sẽ được phát triển tự động thay vì được mã hóa cứng bởi các kỹ sư con
người, sử dụng các bộ phận mô-đun được lưu trữ trong thư viện toàn cầu gồm các chương trình
con có thể tái sử dụng—một thư viện được phát triển bằng cách học các mô hình hiệu suất cao
trên hàng nghìn tác vụ và bộ dữ liệu trước đó. Khi các mẫu giải quyết vấn đề thường xuyên
được xác định bởi hệ thống siêu học tập, chúng sẽ được biến thành các chương trình con có
thể tái sử dụng—giống như các hàm và lớp trong công nghệ phần mềm—và được thêm vào thư viện toàn cầu.
Điều này sẽ đạt được sự trừu tượng.
Thư viện toàn cầu này và hệ thống phát triển mô hình có liên quan sẽ có thể đạt được một số
hình thức khái quát hóa cực đoan giống con người: đưa ra một nhiệm vụ hoặc tình huống mới,

hệ thống sẽ có thể lắp ráp một mô hình làm việc mới phù hợp với nhiệm vụ sử dụng rất
ít dữ liệu, nhờ các nguyên mẫu giống như chương trình phong phú có khả năng khái quát
hóa tốt và kinh nghiệm sâu rộng với các nhiệm vụ tương tự. Theo cách tương tự, con
người có thể nhanh chóng học cách chơi một trò chơi điện tử mới phức tạp nếu họ đã có
kinh nghiệm với nhiều trò chơi trước đó, bởi vì các mô hình bắt nguồn từ trải nghiệm
trước đó là trừu tượng và giống như chương trình, chứ không phải là ánh xạ cơ bản giữa
kích thích và hoạt động.
Như vậy, hệ thống phát triển theo mô hình học hỏi không ngừng này có thể được hiểu là
trí tuệ tổng quát nhân tạo (AGI). Nhưng đừng mong đợi bất kỳ ngày tận thế rô-bốt độc
đoán nào sẽ xảy ra sau đó: đó hoàn toàn là tưởng tượng, xuất phát từ một chuỗi dài
những hiểu lầm sâu sắc về cả trí thông minh và công nghệ. Tuy nhiên, một bài phê bình
như vậy không thuộc về cuốn sách này.

Luôn cập nhật trong một lĩnh vực chuyển động nhanh 337
9.4 Luôn cập nhật trong một lĩnh vực phát triển nhanh Như những
lời chia tay cuối cùng, tôi muốn cung cấp cho bạn một số gợi ý về cách tiếp tục học hỏi và cập
nhật kiến thức cũng như kỹ năng của bạn sau khi bạn lật đến trang cuối cùng của cuốn sách này.
Lĩnh vực học sâu hiện đại, như chúng ta biết ngày nay, chỉ mới ra đời được vài năm, mặc dù đã có
một lịch sử lâu dài và chậm chạp kéo dài hàng thập kỷ. Với sự gia tăng theo cấp số nhân về nguồn
tài chính và số lượng nhân viên nghiên cứu kể từ năm 2013, toàn bộ lĩnh vực này hiện đang phát
triển với tốc độ chóng mặt. Những gì bạn học được trong cuốn sách này sẽ không còn phù hợp mãi mãi
và đó không phải là tất cả những gì bạn cần cho phần còn lại của sự nghiệp.
May mắn thay, có rất nhiều tài nguyên trực tuyến miễn phí mà bạn có thể sử dụng để cập nhật và
mở rộng tầm nhìn của mình. Ở đây có một ít.
9.4.1 Thực hành các vấn đề trong thế giới thực bằng Kaggle
Một cách hiệu quả để có được kinh nghiệm trong thế giới thực là thử tham gia các cuộc thi máy học
trên Kaggle (https://kaggle.com). Cách thực sự duy nhất để học là thông qua thực hành và mã hóa
thực tế—đó là triết lý của cuốn sách này và các cuộc thi Kaggle là sự tiếp nối tự nhiên của điều
này. Trên Kaggle, bạn sẽ tìm thấy một loạt các cuộc thi khoa học dữ liệu được đổi mới liên tục,
nhiều cuộc thi liên quan đến học sâu, được chuẩn bị bởi các công ty quan tâm đến việc đạt được các
giải pháp mới cho một số vấn đề máy học khó khăn nhất của họ. Các giải thưởng tiền tệ khá lớn được
cung cấp cho những người tham gia hàng đầu.
Hầu hết các cuộc thi đều giành chiến thắng khi sử dụng thư viện XGBoost (dành cho máy học nông)
hoặc Keras (dành cho máy học sâu). Vì vậy, bạn sẽ phù hợp ngay trong! Bằng cách tham gia một vài
cuộc thi, có thể là thành viên của một nhóm, bạn sẽ trở nên quen thuộc hơn với khía cạnh thực tế
của một số phương pháp hay nhất nâng cao được mô tả trong cuốn sách này, đặc biệt là điều chỉnh tốc
độ siêu cao, tránh lắp quá mức bộ xác nhận và tập hợp mô hình .
9.4.2 Đọc về những phát triển mới nhất trên arXiv
Nghiên cứu học sâu, trái ngược với một số lĩnh vực khoa học khác, diễn ra hoàn toàn công khai. Các
bài báo được công khai và có thể truy cập miễn phí ngay sau khi chúng được hoàn thiện và rất nhiều
phần mềm liên quan là nguồn mở. arXiv (https://arxiv.org)—pro được gọi là “kho lưu trữ” ( chữ X là
viết tắt của chữ chi trong tiếng Hy Lạp)—là một máy chủ in sẵn truy cập mở dành cho các tài liệu
nghiên cứu về vật lý, toán học và khoa học máy tính. Nó đã trở thành một cách thực tế để cập nhật
những điểm mới nhất của máy học và học sâu. Phần lớn các nhà nghiên cứu học sâu tải bất kỳ bài báo
nào họ viết lên arXiv ngay sau khi hoàn thành. Điều này cho phép họ cắm cờ và tuyên bố một phát
hiện cụ thể mà không cần chờ sự chấp nhận của hội nghị (mất hàng tháng), điều cần thiết với tốc độ
nghiên cứu nhanh và sự cạnh tranh khốc liệt trong lĩnh vực này. Nó cũng cho phép lĩnh vực này di
chuyển cực kỳ nhanh: tất cả các phát hiện mới đều có sẵn ngay lập tức cho tất cả mọi người xem và
tiếp tục phát triển.
Một nhược điểm quan trọng là số lượng lớn các bài báo mới được đăng mỗi ngày trên arXiv khiến
bạn thậm chí không thể đọc lướt qua tất cả; và thực tế là chúng không được đánh giá ngang hàng
khiến việc xác định những thứ vừa quan trọng vừa có chất lượng cao trở nên khó khăn.

Thật khó khăn và ngày càng trở nên khó khăn hơn để tìm ra tín hiệu trong tiếng ồn. Hiện tại,
không có giải pháp tốt cho vấn đề này. Nhưng một số công cụ có thể giúp ích: một trang web phụ
trợ có tên là arXiv Sanity Preserver (http://arxiv-sanity.com) đóng vai trò là công cụ đề xuất
cho các bài báo mới và có thể giúp bạn theo dõi các bước phát triển mới trong một lĩnh vực học
sâu hẹp cụ thể. Ngoài ra, bạn có thể sử dụng Google Scholar (https://scholar.google.com) để theo
dõi các ấn phẩm của các tác giả yêu thích của bạn.
9.4.3 Khám phá hệ sinh thái Keras
Với khoảng 200.000 người dùng tính đến tháng 11 năm 2017 và đang tăng nhanh, Keras có một hệ
sinh thái lớn gồm các hướng dẫn, hướng dẫn và các dự án nguồn mở liên quan:
Tài liệu tham khảo chính của bạn để làm việc với Keras là tài liệu trực tuyến tại https://
keras.io. Bạn có thể tìm thấy mã nguồn Keras tại https://github.com/fchollet/keras .
Bạn có thể yêu cầu trợ giúp và tham gia các cuộc thảo luận về học sâu trên kênh Keras
Slack: https://kerasteam.slack.com. Blog Keras, https://blog.keras.io, cung cấp các
bài hướng dẫn về Keras và các bài viết khác liên quan đến deep learning. Bạn có thể theo
dõi tôi trên Twitter: @fchollet.

Từ cuối cùng 339
9.5 Lời kết

Đây là phần cuối của Deep Learning với Python! Tôi hy vọng bạn đã học được một vài điều về học
máy, học sâu, Keras và thậm chí có thể là nhận thức nói chung. Học hỏi là một hành trình suốt
đời, đặc biệt là trong lĩnh vực AI, nơi chúng ta có nhiều điều chưa biết hơn là sự chắc chắn. Vì
vậy, hãy tiếp tục học hỏi, đặt câu hỏi và nghiên cứu.
Không bao giờ dừng lại. Bởi vì ngay cả với những tiến bộ đã đạt được cho đến nay, hầu hết các
câu hỏi cơ bản về AI vẫn chưa được trả lời. Nhiều người thậm chí còn chưa được hỏi chính xác.

Phụ lục A
Cài đặt Keras và các phụ
thuộc của nó trên Ubuntu
Quá trình thiết lập một máy trạm học sâu khá phức tạp và bao gồm các bước sau, phụ lục này sẽ
đề cập chi tiết:
1 Cài đặt bộ khoa học Python—Numpy và SciPy—và đảm bảo rằng bạn đã cài đặt thư viện Chương
trình con Đại số Tuyến tính Cơ bản (BLAS) để các mô hình của bạn chạy nhanh trên CPU.
2 Cài đặt hai gói bổ sung hữu ích khi sử dụng Keras: HDF5 (để lưu các tệp mạng thần kinh
lớn) và Graphviz (để trực quan hóa kiến trúc mạng thần kinh).
3 Đảm bảo GPU của bạn có thể chạy mã học sâu bằng cách cài đặt trình điều khiển CUDA
và cuDNN.
4 Cài đặt chương trình phụ trợ cho Máy ảnh: TensorFlow, CNTK hoặc Theano.
5 Cài đặt máy ảnh.
Nó có vẻ giống như một quá trình khó khăn. Trên thực tế, phần khó khăn duy nhất là thiết lập
hỗ trợ GPU —nếu không, toàn bộ quá trình có thể được thực hiện bằng một vài lệnh và chỉ mất
vài phút.
Chúng tôi sẽ cho rằng bạn có bản cài đặt Ubuntu mới, có sẵn GPU NVIDIA . Trước khi bắt
đầu, hãy đảm bảo rằng bạn đã cài đặt pip và trình quản lý gói của bạn đã được cập nhật:
$ sudo apt-get cập nhật $ sudo

apt-get nâng cấp $ sudo apt-get
cài đặt python-pip python-dev
340

Cài đặt bộ khoa học Python 341
Python 2 so với Python 3

Theo mặc định, Ubuntu sử dụng Python 2 khi cài đặt các gói Python như python pip. Nếu
bạn muốn sử dụng Python 3 thay thế, bạn nên sử dụng tiền tố python3 thay vì python. Ví dụ:
$ sudo apt-get cài đặt python3-pip python3-dev
Khi bạn đang cài đặt các gói bằng pip, hãy nhớ rằng theo mặc định, nó nhắm mục tiêu Python
2. Để nhắm mục tiêu Python 3, bạn nên sử dụng pip3:
$ sudo pip3 cài đặt tensorflow-gpu
A.1 Cài đặt bộ khoa học Python

Nếu bạn sử dụng máy Mac, chúng tôi khuyên bạn nên cài đặt bộ khoa học Python qua Ana conda, bạn có
thể tải bộ này tại www.continuum.io/downloads. Lưu ý rằng điều này sẽ không bao gồm HDF5 và Graphviz
mà bạn phải cài đặt thủ công. Sau đây là các bước để cài đặt thủ công bộ khoa học Python trên Ubuntu:
1 Cài đặt thư viện BLAS ( trong trường hợp này là OpenBLAS), để đảm bảo rằng bạn có thể chạy nhanh
hoạt động tensor trên CPU của bạn:

$ sudo apt-get cài đặt bản dựng cần thiết cmake git giải nén \
pkg-config libopenblas-dev liblapack-dev
2 Cài đặt bộ khoa học Python: Numpy, SciPy và Matplotlib. Điều này là cần thiết để thực hiện bất
kỳ loại máy học hoặc tính toán khoa học nào bằng Python, bất kể bạn có đang học sâu hay không:
$ sudo apt-get cài đặt python-numpy python-scipy python- matplotlib python-yaml
3 Cài đặt HDF5. Thư viện này, do NASA phát triển ban đầu, lưu trữ các tệp dữ liệu số lớn ở định
dạng nhị phân hiệu quả. Nó sẽ cho phép bạn lưu các mô hình Keras của mình vào đĩa một cách
nhanh chóng và hiệu quả:
$ sudo apt-get cài đặt libhdf5-serial-dev python-h5py
4 Cài đặt Graphviz và pydot-ng, hai gói cho phép bạn trực quan hóa các mô hình Keras. Chúng không
cần thiết để chạy Keras, vì vậy bạn có thể bỏ qua bước này và cài đặt các gói này khi cần.
Dưới đây là các lệnh:
$ sudo apt-get cài đặt graphviz $ sudo pip cài

đặt pydot-ng
5 Cài đặt các gói bổ sung được sử dụng trong một số ví dụ về mã của chúng tôi:
$ sudo apt-get cài đặt python-opencv

342 PHỤ LỤC A Cài đặt Keras và các phần phụ thuộc của nó trên Ubuntu
A.2 Thiết lập hỗ trợ GPU Việc sử dụng
GPU không thực sự cần thiết nhưng chúng tôi thực sự khuyên bạn nên sử dụng. Tất cả các
bài kiểm tra mã tìm thấy trong cuốn sách này đều có thể chạy trên CPU máy tính xách tay,
nhưng đôi khi bạn có thể phải đợi vài giờ để mô hình đào tạo, thay vì chỉ vài phút trên
GPU tốt. Nếu không có GPU NVIDIA hiện đại, bạn có thể bỏ qua bước này và chuyển thẳng đến phần A.3.
Để sử dụng GPU NVIDIA cho deep learning, bạn cần cài đặt hai thứ: CUDA—Một
bộ trình điều khiển cho GPU của bạn cho phép GPU chạy ngôn ngữ kết hợp chương trình
cấp thấp để tính toán song song. cuDNN—Một thư viện nguyên thủy được tối ưu hóa
cao cho deep learning. Khi sử dụng cuDNN và chạy trên GPU, thông thường bạn có thể
tăng tốc độ đào tạo của các mô hình của mình từ 50% đến 100%.
TensorFlow phụ thuộc vào các phiên bản cụ thể của CUDA và thư viện cuDNN . Tại thời điểm
viết bài này, nó sử dụng CUDA phiên bản 8 và cuDNN phiên bản 6. Vui lòng tham khảo trang
web TensorFlow để biết hướng dẫn chi tiết về những phiên bản hiện đang được khuyến nghị:
www.tensorflow.org/install/install_linux.
Làm theo các bước
sau: 1 Tải xuống CUDA. Đối với Ubuntu (và các hương vị Linux khác), NVIDIA cung cấp
gói sẵn sàng sử dụng mà bạn có thể tải xuống từ https://developer .nvidia.com/cuda-
downloads:
$ wget http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1604/ x86_64/cuda-

repo-ubuntu1604_9.0.176-1_amd64.deb
2 Cài đặt CUDA. Cách dễ nhất để làm như vậy là sử dụng apt của Ubuntu trên gói này.
Điều này sẽ cho phép bạn dễ dàng cài đặt các bản cập nhật qua apt khi chúng có sẵn:
$ sudo dpkg -i cuda-repo-ubuntu1604_9.0.176-1_amd64.deb $ sudo apt-key adv --fetch-
keys http://developer.download .nvidia.com/compute/cuda/repos/ubuntu1604/
x86_64/7fa2af80.pub $ sudo apt-get update $ sudo apt-get cài đặt cuda-8-0
3 Cài đặt cuDNN:
a Đăng ký tài khoản nhà phát triển NVIDIA miễn phí (thật không may, điều này là cần
thiết để có quyền truy cập vào bản tải xuống cuDNN ) và tải xuống cuDNN tại
https://developer.NVIDIA.com/cudnn (chọn phiên bản cuDNN tương thích với
TensorFlow). Giống như CUDA, NVIDIA cung cấp các gói dành cho các phiên bản Linux
khác nhau—chúng tôi sẽ sử dụng phiên bản dành cho Ubuntu 16.04. Lưu ý rằng nếu
đang làm việc với bản cài đặt EC2, bạn sẽ không thể tải trực tiếp kho lưu trữ
cuDNN xuống phiên bản của mình; thay vào đó, hãy tải nó xuống máy cục bộ của bạn
rồi tải nó lên phiên bản EC2 của bạn (thông qua scp).
b Cài đặt cuDNN:
$ sudo dpkg -i dpkg -i libcudnn6*.deb

Cài đặt máy ảnh 343
4 Cài đặt TensorFlow:
có thể cài đặt TensorFlow có hoặc không có hỗ trợ GPU từ PyPI bằng Pip. Đây là lệnh không
hỗ trợ GPU : $ sudo pip install tensorflow
b Đây là lệnh cài đặt TensorFlow có hỗ trợ GPU :
$ sudo pip cài đặt tensorflow-gpu
A.3 Cài đặt Theano (tùy chọn)

Vì bạn đã cài đặt TensorFlow nên bạn không cần phải cài đặt Theano để chạy mã Keras. Nhưng đôi
khi có thể hữu ích để chuyển đổi qua lại từ
TensorFlow cho Theano khi xây dựng các mô hình Keras.
Theano cũng có thể được cài đặt từ PyPI:
$ sudo pip cài đặt theano
Nếu đang sử dụng GPU, bạn nên định cấu hình Theano để sử dụng GPU của mình. Bạn có thể tạo tệp
cấu hình Theano bằng lệnh này:
nano ~/.theanorc
Sau đó, điền vào tệp với cấu hình sau:
[toàn cầu]
floatX = float32
thiết bị = gpu0
[nvcc]
toán nhanh = Đúng
A.4 Cài đặt máy ảnh

Bạn có thể cài đặt Keras từ PyPI:
$ Sudo pip cài đặt máy ảnh
Ngoài ra, bạn có thể cài đặt Keras từ GitHub. Làm như vậy sẽ cho phép bạn truy cập vào thư mục
máy ảnh/ví dụ, thư mục chứa nhiều tập lệnh ví dụ để bạn học hỏi:
$ git clone https://github.com/fchollet/keras $ cd máy ảnh $ sudo python

setup.py cài đặt
Bây giờ, bạn có thể thử chạy tập lệnh Keras, chẳng hạn như ví dụ MNIST sau:
ví dụ về python/mnist_cnn.py
Lưu ý rằng việc chạy ví dụ này để hoàn thành có thể mất vài phút, vì vậy vui lòng thoát khỏi ví
dụ (Ctrl-C) sau khi bạn đã xác minh rằng nó hoạt động bình thường.
Sau khi bạn đã chạy Keras ít nhất một lần, bạn có thể tìm thấy tệp cấu hình Keras tại
~/.keras/keras.json. Bạn có thể chỉnh sửa nó để chọn chương trình phụ trợ mà Keras chạy trên đó:
tensorflow, theano hoặc cntk. Tệp cấu hình của bạn sẽ như thế này:

344 PHỤ LỤC A Cài đặt Keras và các phần phụ thuộc của nó trên Ubuntu
{
"image_data_format": "channels_last",
"epsilon": 1e-07, "floatx": "float32",
"backend": "tensorflow"
Trong khi tập lệnh Keras ví dụ/mnist_cnn.py đang chạy, bạn có thể theo dõi việc sử dụng
GPU trong một cửa sổ trình bao khác:
$ watch -n 5 NVIDIA-smi -a --display=utilization
Bạn đã sẵn sàng! Xin chúc mừng—giờ đây bạn có thể bắt đầu xây dựng các ứng dụng học sâu.

Phụ lục B
Chạy máy tính xách tay
Jupyter trên phiên bản GPU EC2
Phụ lục này cung cấp hướng dẫn từng bước để chạy sổ ghi chú Jupyter học sâu trên phiên bản
GPU AWS và chỉnh sửa sổ ghi chép từ mọi nơi trong trình duyệt của bạn. Đây là thiết lập
hoàn hảo cho nghiên cứu học sâu nếu bạn không có GPU trên máy cục bộ của mình. Bạn có thể
tìm thấy phiên bản gốc (và cập nhật) của hướng dẫn này tại https://blog.keras.io.
B.1 Sổ tay Jupyter là gì?

Tại sao chạy sổ ghi chép Jupyter trên GPU AWS?
Sổ tay Jupyter là một ứng dụng web cho phép bạn viết và chú thích mã Python một cách tương
tác. Đó là một cách tuyệt vời để thử nghiệm, nghiên cứu và chia sẻ những gì bạn đang làm.
Nhiều ứng dụng học sâu rất chuyên sâu về tính toán và có thể mất hàng giờ hoặc thậm chí
hàng ngày khi chạy trên lõi CPU của máy tính xách tay. Chạy trên GPU có thể tăng tốc độ đào
tạo và suy luận lên một hệ số đáng kể (thường gấp 5 đến 10 lần, khi chuyển từ một CPU hiện
đại sang một GPU hiện đại duy nhất ). Nhưng bạn có thể không có quyền truy cập vào GPU trên
máy cục bộ của mình. Chạy sổ ghi chép Jupyter trên AWS mang lại cho bạn trải nghiệm giống
như chạy trên máy cục bộ của bạn, đồng thời cho phép bạn sử dụng một hoặc nhiều GPU trên
AWS. Và bạn chỉ trả tiền cho những gì bạn sử dụng, điều này có thể so sánh thuận lợi với
việc đầu tư vào (các) GPU của riêng bạn nếu bạn chỉ thỉnh thoảng sử dụng deep learning.
345

346 PHỤ LỤC B Chạy sổ ghi chép Jupyter trên phiên bản GPU EC2
B.2 Tại sao bạn không muốn sử dụng Jupyter trên

AWS để học sâu?
Các phiên bản GPU AWS có thể nhanh chóng trở nên đắt đỏ. Cái chúng tôi đề xuất sử dụng có giá 0,90
đô la mỗi giờ. Điều này tốt cho việc sử dụng không thường xuyên; nhưng nếu bạn định chạy thử nghiệm
trong vài giờ mỗi ngày, thì tốt hơn hết bạn nên xây dựng cỗ máy học sâu của riêng mình bằng TITAN X
hoặc GTX 1080 Ti.
Tóm lại, hãy sử dụng thiết lập Jupyter-on-EC2 nếu bạn không có quyền truy cập vào GPU cục bộ hoặc
nếu bạn không muốn xử lý việc cài đặt các phần phụ thuộc của Keras, cụ thể là trình điều khiển GPU .
Thay vào đó, nếu bạn có quyền truy cập vào GPU cục bộ, chúng tôi khuyên bạn nên chạy các mô hình của
mình cục bộ. Trong trường hợp đó, hãy sử dụng hướng dẫn cài đặt trong phụ lục A.
LƯU Ý Bạn sẽ cần một tài khoản AWS đang hoạt động . Một số kiến thức quen thuộc với AWS
EC2 sẽ hữu ích nhưng không bắt buộc.
B.3 Thiết lập phiên bản GPU AWS

Quá trình thiết lập sau đây sẽ mất từ 5 đến 10 phút:
1 Điều hướng đến bảng điều khiển EC2 tại https://console.aws.amazon.com/ec2/v2, và nhấp vào liên
kết Launch Instance (xem hình B.1).
Hình B.1 Bảng điều

khiển EC2
2 Chọn AWS Marketplace (xem hình B.2) và tìm kiếm “deep learning” trong hộp tìm kiếm. Cuộn xuống
cho đến khi bạn tìm thấy AMI có tên Deep Learning AMI Ubuntu Version (xem hình B.3); chọn nó.
Hình B.2 Thị trường AMI EC2

Thiết lập phiên bản GPU AWS 347
Hình B.3 AMI học sâu EC2
3 Chọn phiên bản p2.xlarge (xem hình B.4). Loại phiên bản này cung cấp quyền truy cập vào
một GPU duy nhất và có giá 0,9 USD/giờ sử dụng (kể từ tháng 3 năm 2017).
Hình B.4 Phiên bản p2.xlarge
4 Bạn có thể giữ cấu hình mặc định cho các bước Định cấu hình phiên bản, Thêm dung
lượng lưu trữ và Thêm thẻ nhưng bạn sẽ tùy chỉnh bước Định cấu hình nhóm bảo mật.
Tạo quy tắc TCP tùy chỉnh để cho phép cổng 8888 (xem hình B.5): quy tắc này có thể được
cho phép đối với IP công cộng hiện tại của bạn (chẳng hạn như IP của máy tính xách tay
của bạn) hoặc cho bất kỳ IP nào (chẳng hạn như 0.0.0.0/0) nếu trước đây là không thể. Lưu
ý rằng nếu bạn cho phép cổng 8888 cho bất kỳ IP nào, thì theo nghĩa đen, bất kỳ ai cũng
có thể nghe cổng đó trên phiên bản của bạn (đó là nơi bạn sẽ chạy sổ ghi chép IPython).
Bạn sẽ thêm tính năng bảo vệ bằng mật khẩu cho sổ ghi chép để giảm thiểu nguy cơ bị người
lạ ngẫu nhiên sửa đổi chúng, nhưng cách bảo vệ đó có thể khá yếu. Nếu có thể, bạn nên xem
xét việc hạn chế quyền truy cập vào một IP cụ thể. Nhưng nếu địa chỉ IP của bạn thay đổi
liên tục thì đó không phải là lựa chọn thiết thực. Nếu bạn định để mở quyền truy cập vào
bất kỳ IP nào, thì hãy nhớ không để lại dữ liệu nhạy cảm trên phiên bản đó.

Hình B.5 Định cấu hình nhóm bảo mật mới.
LƯU Ý Khi kết thúc quá trình khởi chạy, bạn sẽ được hỏi liệu bạn muốn tạo các khóa
kết nối mới hay bạn muốn sử dụng lại các khóa hiện có. Nếu bạn chưa từng sử dụng
EC2 trước đây, hãy tạo các khóa mới và tải chúng xuống.
5 Để kết nối với phiên bản của bạn, hãy chọn phiên bản đó trên bảng điều khiển EC2 ,
nhấp vào nút Kết nối và làm theo hướng dẫn (xem hình B.6). Lưu ý rằng có thể mất
vài phút để phiên bản khởi động. Nếu bạn không thể kết nối lúc đầu, hãy đợi một
chút và thử lại.
Hình B.6 Hướng dẫn kết nối
6 Khi bạn đã đăng nhập vào phiên bản qua SSH, hãy tạo một thư mục ssl ở thư mục gốc
của phiên bản và cd vào đó (không bắt buộc, nhưng sạch hơn):
$ mkdir ssl $
cd ssl

Thiết lập phiên bản GPU AWS 349
7 Tạo chứng chỉ SSL mới bằng OpenSSL và tạo cert.key và cert.pem
các tệp trong thư mục ssl hiện tại:
$ openssl req -x509 -nodes -days 365 -newkey rsa:1024 -keyout "cert.key" -out "cert.pem" -batch
2.3.1 Định cấu hình Jupyter
Trước khi sử dụng Jupyter, bạn cần chỉnh sửa cấu hình mặc định của nó. Thực hiện theo các
bước sau:
1 Tạo tệp cấu hình Jupyter mới (vẫn trên phiên bản từ xa):
$ máy tính xách tay jupyter --generate-config
2 Theo tùy chọn, bạn có thể tạo mật khẩu Jupyter cho sổ ghi chép của mình. Vì phiên bản
của bạn có thể được định cấu hình để có thể truy cập được từ bất kỳ IP nào (tùy thuộc
vào lựa chọn bạn đã thực hiện khi định cấu hình nhóm bảo mật), tốt hơn hết bạn nên hạn
chế quyền truy cập vào Jupyter thông qua mật khẩu. Để tạo mật khẩu, hãy mở trình bao
IPython (lệnh ipython ) và chạy như sau:
từ IPython.lib nhập passwd passwd() thoát
3 Lệnh passwd() sẽ yêu cầu bạn nhập và xác minh mật khẩu. Sau khi bạn thực hiện, nó sẽ
hiển thị một hàm băm mật khẩu của bạn. Sao chép mã băm đó—bạn sẽ sớm cần đến nó.
Nó trông giống như thế này:
sha1:b592a9cf2ec6:b99edb2fd3d0727e336185a0b0eab561aa533a43
Lưu ý rằng đây là hàm băm của từ mật khẩu, đây không phải là mật khẩu bạn nên sử dụng.
4 Sử dụng vi (hoặc trình soạn thảo văn bản có sẵn yêu thích của bạn) để chỉnh sửa tệp cấu hình Jupyter:
$ vi ~/.jupyter/jupyter_notebook_config.py
5 Tệp cấu hình là tệp Python với tất cả các dòng đã được nhận xét. Chèn các
dòng mã Python sau vào đầu tệp:
Đường dẫn đến khóa riêng mà Phục vụ sổ
bạn đã tạo cho chứng chỉ ghi chép tại địa phương
Đường dẫn đến chứng chỉ Hình nội tuyến khi

bạn đã tạo Lấy đối tượng cấu hình sử dụng Matplotlib
c = get_config()
c.NotebookApp.certfile = u'/home/ubuntu/ssl/cert.pem' c.NotebookApp.keyfile = u'/
home/ubuntu/ssl/cert.key' c.IPKernelApp.pylab = ' nội tuyến' c.NotebookApp.ip =
'*'
c.NotebookApp.open_browser = Sai c.NotebookApp.password

= 'sha1:b592a9cf2ec6:b99edb2fd3d0727e336185a0b0eab561aa533a43'
Không mở cửa sổ trình duyệt theo Băm mật khẩu bạn đã

mặc định khi sử dụng sổ ghi chép. tạo trước đó

LƯU Ý Trong trường hợp bạn không quen sử dụng vi, hãy nhớ rằng bạn cần nhấn I để bắt
đầu chèn nội dung. Khi bạn hoàn tất, nhấn Esc, nhập :wq, rồi nhấn Enter để thoát khỏi
vi và lưu các thay đổi của bạn (:wq là viết tắt của write-quit).
B.4 Cài đặt máy ảnh Bạn gần như
đã sẵn sàng để bắt đầu sử dụng Jupyter. Nhưng trước tiên, bạn cần cập nhật Keras. Một phiên bản
của Keras được cài đặt sẵn trên AMI, nhưng nó có thể không nhất thiết phải được cập nhật. Trong
trường hợp từ xa, hãy chạy lệnh này:
$ Sudo pip cài đặt máy ảnh --upgrade
Bởi vì bạn có thể sẽ sử dụng Python 3 (sổ ghi chép đi kèm với cuốn sách này sử dụng
Python 3), bạn cũng nên cập nhật Keras bằng pip3:
$ Sudo pip3 cài đặt máy ảnh --upgrade
Nếu có một tệp cấu hình Keras hiện có trong phiên bản (không nên có, nhưng AMI có thể đã thay đổi
kể từ khi tôi viết bài này), bạn nên xóa nó đi, đề phòng. Máy ảnh sẽ tạo lại một tệp cấu hình
tiêu chuẩn khi nó được khởi chạy lần đầu tiên.
Nếu đoạn mã sau trả về lỗi nói rằng tệp không tồn tại, bạn có thể bỏ qua nó:
$ rm -f ~/.keras/keras.json
B.5 Thiết lập chuyển tiếp cổng cục bộ

Trong trình bao trên máy cục bộ của bạn (không phải phiên bản từ xa), hãy bắt đầu chuyển tiếp
cổng cục bộ 443 ( cổng HTTPS ) sang cổng 8888 của phiên bản từ xa:
$ Sudo ssh -i awsKeys.pem -L local_port:local_machine:remote_port remote_machine
Trong trường hợp của tôi, nó sẽ giống như sau:
$ sudo ssh -i awsKeys.pem -L

443:127.0.0.1:8888 ubuntu@ec2-54-147-126-214.compute-1.amazonaws.com
B.6 Sử dụng Jupyter từ trình duyệt cục bộ của bạn

Trong trường hợp từ xa, hãy sao chép kho lưu trữ GitHub chứa sổ ghi chú Jupyter được liên kết
với cuốn sách này:
$ git clone https://github.com/fchollet/deep-learning-with-python-notebooks.git cd deep-learning-with-

python-notebooks
Khởi động Jupyter Notebook bằng cách chạy lệnh này, vẫn trên phiên bản từ xa:
máy tính xách tay $ jupyter
Sau đó, trong trình duyệt cục bộ của bạn, hãy điều hướng đến địa chỉ cục bộ mà bạn đang chuyển
tiếp tới quy trình sổ ghi chép từ xa (https://127.0.0.1). Đảm bảo bạn sử dụng HTTPS trong địa
chỉ, nếu không bạn sẽ gặp lỗi SSL .

Sử dụng Jupyter từ trình duyệt cục bộ của bạn 351
Bạn sẽ thấy cảnh báo an toàn trong hình B.7. Cảnh báo này là do chứng chỉ SSL bạn đã
tạo không được xác minh bởi cơ quan đáng tin cậy (rõ ràng là bạn đã tạo chứng chỉ của
riêng mình). Nhấp vào Nâng cao và tiếp tục điều hướng.
Hình B.7 Cảnh báo an toàn bạn có thể bỏ qua
Bạn sẽ được nhắc nhập mật khẩu Jupyter của mình. Sau đó, bạn sẽ đến bảng điều khiển Jupy
ter (xem hình B.8).
Hình B.8 Bảng điều khiển Jupyter
Chọn Mới > Notebook để bắt đầu (xem hình B.9). Bạn
có thể sử dụng phiên bản Python mà bạn chọn. Tất
cả các thiết lập!
Hình B.9 Tạo một sổ tay mới.


mục lục
ký hiệu kiến trúc mạng 319–322 b

kết nối 321 mạng
* kết nối dày đặc 319–320
toán tử 40 + Babbage, công cụ phụ
toán tử 99 mạng thần kinh hồi quy 321–322 trợ Charles 4, thuật toán
lan truyền ngược Keras 62 11,
51–52, 246 chuyền
sô ho c
ngược 49 túi 2 gam 181 túi 3
các mẫu kiến trúc của các gam 181 túi từ 181
tenxơ 0D. Xem tích
mô hình 260–263
chập 1D vô hướng 225–227 chuẩn hóa hàng loạt 260–
gộp 1D, để biết dữ liệu 261 tích chập có Baidu 22
chuỗi 226 tenxơ 1D.
thể tách rời theo chiều trục lô 35 chuẩn
Xem vectơ tenxơ 2D. Xem ma sâu 261–263 kết nối dư hóa lô 22
trận nhúng 3D 253 235–236, 244–246
BatchNormalization lớp 260
batch_size 211
mũi tên thời gian
Bengio, Yoshua 17, 188, 202
100 trí tuệ nhân tạo 3–13,
Một lớp hai chiều 207 phân loại
270 kỳ vọng cho 13
nhị phân 68–77, 96
kích hoạt 160 lịch sử 12–13 arXiv máy
chức năng kích hoạt 22 chủ in sẵn 271, 337–338
crossentropy nhị phân 60, 72
lắp ráp bộ dữ liệu 111–112 hộp đen 160
nhắm mục tiêu quảng
trí tuệ tăng cường
cáo 12 phương pháp add_loss 302 BLAS (Đại số tuyến tính cơ bản
270 dữ liệu tăng cường 138–142
ADMM (phương pháp định hướng Chương trình con) 39,
luân phiên của số nhân) trích xuất tính năng với trích 340 hiệu ứng đường viền 125–126
xuất tính năng 149–152 mà không
332 mạng đối nghịch 310 cần 147 –149 bộ mã hóa tự hoạt động phát sóng 39–40 trình
duyệt, cục bộ, sử dụng
động. Xem VAE (bộ mã
Xem thêm học sâu tổng hóa tự động biến đổi) Jupyter từ 350–351
quát; mạng đối thủ
tạo ra mạng đối thủ
305 phép biến đổi affine 72 C

Amazon Web Services. Xem AWS
Hệ thống AutoML 333
AMD 20 Analytical Engine 4 chú
lái xe tự động 12 gọi lại, viết 251–252
thích 94, 96 giao diện chương AWS (Dịch vụ web của Amazon) CAM (bản đồ kích hoạt lớp)
trình ứng dụng. Các phiên bản 172 mã hóa phân loại
GPU chạy Jupyter trên 350 79 hàm phân loại_crossentropy

đang thiết lập 346–350 53, 80, 83
Xem API chức năng bằng Jupyter trên 346
353

354 MỤC LỤC
CERN 17 trực quan hóa quá trình học tenxơ chiều cao hơn
kênh trục 123 kênh- convnet 160–176 bộ lọc 32 dữ liệu hình
quy ước đầu tiên 36 kênh-quy ước convnet 167–172 bản đồ nhiệt ảnh 36–37 thuộc tính
cuối cùng 36 mô hình ngôn ngữ kích hoạt lớp 172–176 kích chính của tenxơ 32–33 thao
hoạt trung gian 160–166 tác với tenxơ trong
thần kinh cấp ký tự 272
bộ lọc convnets 160 cơ sở
Ciresan, Dan 17, kích tích chập 143–144 hoạt Numpy 34 ma

động tích chập 122–127 hiệu ứng trận (tenxơ 2D) 31–32
hoạt lớp 20, trực quan hóa bản đồ
viền 125–126 bước tích chập 127 vô hướng (tenxơ 0D)
nhiệt của 172–176 lớp 27,
31 dữ liệu trình tự 35–36
96 phân loại 60 chèo 125–126 bước tích chập 127
tích chập dữ liệu chuỗi thời gian
35–36 dữ liệu vectơ 35
đám mây, chạy các công việc
vectơ (tenxơ 1D) 31 dữ
trong 66 cụm 94 CNN. Xem
liệu video 37 xáo trộn 98,
convnets (mạng lưới thần kinh
100 tách 98 mã hóa 189–190
phức tạp)
chuyển đổi 10 biến đổi 6
CNTK (Bộ công cụ nhận thức của
1D 225–226 có vector hóa 101 tăng dữ liệu
Microsoft) 62 bước
130 chắt lọc dữ liệu 28
biên dịch 29 vectơ khái niệm, thể tách rời theo chiều
sâu 261–263
để chỉnh sửa hình ảnh 297–298
Cortes, Corinna 15
điều chỉnh dữ liệu 272
Nút kết nối, bảng điều khiển crossentropy 73
EC2 348 kết nối, mất nội dung Trình điều khiển CUDA 20, 340,
244–246 còn lại 288 342 thư viện cuDNN 62, 340, 342
điểm dữ liệu 27, 220
độ cong 48
tính đại diện của dữ liệu 100
biến dữ liệu, ví dụ về 35 bộ dữ
lớp Conv1D 226 Đ. liệu, tập hợp 111–112
Conv2D lớp 120, 122, 124 DCGAN (tích chập sâu
convnets (mạng nơ ron tích chập) 321 dữ liệu GANs)
tổng quan 307
tăng thêm 138–142
1D 226–227 trích xuất tính năng với đào tạo 310–312
149–152 trích xuất ranh giới quyết định 15
kết hợp với mạng thần kinh
tái phát 228–231 tổng tính năng mà không có 147–149 cây quyết định 16–17 kết
quan 120–129 phép toán lô 34–35 tạo dữ liệu chuỗi nối sâu 266 học sâu 3, 6–
tích chập 122–127 phép toán 272 không đồng nhất 101 đồng 13 thành tựu của 11–12
tổng hợp tối đa 127–129 nhất 101 biểu diễn học tập từ 6– thành tựu của 315–316 dân chủ
hóa 23 công nghệ hỗ trợ 317–
trình tự xử lý với 225– 8 thiếu 102 chuẩn bị 112–
318 tương lai của 23–24, Máy
231 113 cho LSTM cấp ký tự
tự động 330–336
đào tạo về tập dữ liệu nhỏ

học tập 332–333 học
130–142 xây dựng mạng
tập suốt đời 333–335 tầm nhìn
133–135 tiền xử lý dữ liệu
dài hạn 335–336 mô hình dưới
135–138 mức độ phù hợp tạo văn bản 274
dạng chương trình 330–332 tái
với dữ liệu nhỏ cho thần kinh tái phát
sử dụng chương trình con
mạng 210–212 tiền xử mô-đun
lý 101–103, 135–138 Giải
vấn đề 130–131 sử thích hình học 333–335 của phần
dụng tăng cường dữ liệu 138– dự phòng 100 biểu cứng 44–45 và đầu tư 20–
142 sử dụng kết nối được diễn cho mạng thần kinh 31–37 21 vào các giới hạn 22–23 của
huấn luyện trước 143–159 trích 325–329
xuất tính năng 143–152 tenxơ 3D 32 lô
tinh chỉnh 152–158 dữ liệu 34–35
khái quát hóa cục bộ vs.
ví dụ về tenxơ dữ liệu 35 tổng quát hóa cực đoan 327–
329

MỤC LỤC 355
học sâu, hạn chế (tiếp theo) hoạt động thông minh về phần tử 38– g
rủi ro của các mô hình 39 lớp nhúng, tìm hiểu cách nhúng
học máy được nhân hóa 325– từ với 185–187 tính năng Gal, Yarin 216
327 tổng quan 9–11, 316– kỹ thuật 101–103 mô hình
GAN (mạng đối thủ chung) 296,
317 khả năng sử dụng 322– tập hợp 264–266 kỷ nguyên 53, 74, 305 lớp đơn vị lặp lại
324 lý do quan tâm đến 20–24 76, 82 epsilon 300 đánh giá mô hình có kiểm soát.
192–195 giao thức đánh giá, chọn Xem các lớp GRU
chuyên gia 100, 112 hệ thống 4 Gatys, Leon 287 Phân
Xem thêm học sâu tổng quát tổng quát hóa cực đoan, tổng quát phối Gaussian 307 khái quát
hóa cục bộ so với 327–329 khởi đầu hóa 104, 327–329 học sâu tổng
AMI học sâu, EC2 66 cực đoan 244 quát tạo ra hình ảnh với các bộ
Kỹ thuật DeepDream 280– mã hóa tự động khác nhau 296–304
286 tổng quan
280 triển khai trong
Keras 281–286 các vectơ khái niệm để chỉnh

sửa hình ảnh 297–298 lấy
DeepMind, Google 22, 95 mẫu từ các không gian tiềm
Các lớp dày đặc 28, 38, 53, 69–70, F ẩn của hình ảnh 296–297
122, 187, 213, 321 lấy tạo văn bản với LSTM 271–
mẫu dày đặc 328 mạng kết nối dày kỹ thuật tính năng 16, 18 học 279 tạo dữ liệu chuỗi 272 lịch
đặc 319–320 sử của các mạng thuê định
tính năng 101–103 bản đồ tính
năng 123, 129 tính năng kỳ tạo ra 271 triển khai tạo
dẫn xuất tích chập 321 văn bản LSTM cấp ký tự
có thể phân tách
kỹ thuật 101–103 trích 274–279 chiến lược lấy mẫu
theo chiều sâu, tài khoản nhà 272–274 tạo ra mạng đối
xuất 143–152 có tăng
phát triển 47–48 được xác định, thủ 305–313
cường dữ liệu 149–152 không
trợ lý kỹ thuật số
tăng cường dữ liệu 147–
NVIDIA 342 12 chiều 31
149 có các mạng chuyển tiếp
trục 35 196, 202
chiều 31, 94 đồ thị tuần
hoàn có hướng của các lớp
242–246 mô-đun khởi mạng đối thủ 310 mạng phân
Feynman, Richard 316
tạo 242–244 kết nối còn lại 244– fill_mode 139 trực quan biệt 307–309 mạng tạo 307–
246 tổng quan về mạng phân biệt 308 triển khai sơ đồ của
hóa bộ lọc 172 tổng quan
305 triển khai 307–309 về bộ lọc 124 kết nối, 307 đào tạo DCGAN 310–312
trực quan hóa 167–172 chuyển kiểu thần kinh
tinh chỉnh 152–158 phương pháp 287–295 mất nội dung 288
trong Keras 289–295 mất
khớp 29 phương pháp fit_generator
hàm khoảng cách 288 thao
136 kiểu 288–289 học sâu tổng quát,
tác chấm 40–42 tích 38
tải xuống Làm phẳng lớp 133
Flickr 21
Nhúng từ GloVe 190 văn bản thô float32 29, 101, 173
189
cho vòng lặp 38, 197,
Lớp bỏ học 140 thuộc 331 chuyển tiếp 46 lớp DeepDream 280–286 mạng
tính dtype 32–33 đóng băng 150 lớp được lặp lại tổng quát, lịch sử của 271
kết nối đầy đủ 58 API chức chức năng bộ tạo 211, 230
e năng, Keras 234–248 đồ thị tuần mạng bộ tạo, triển khai 307–308
hoàn có hướng của lớp 242–246 giải thích hình học của học sâu 44–
Gọi lại EarlyStopping 250 chia sẻ trọng lượng lớp 45 của hoạt động tensor 43–
Eck, Douglas 271 246–247 mô hình dưới dạng lớp 247 44 không gian hình học 316
chỉnh sửa hình ảnh, vectơ khái niệm –248 kiểu đa đầu vào 238–240 kiểu
cho 297–298 đa đầu ra 240–242
bản địa 62

356 MỤC LỤC
GloVe (Vectơ toàn cầu cho Word Hinton, Geoffrey 17, 109 Máy ảnh 343–344, 350
Đại diện) tải Hochreiter, tháng 9 năm MởBLAS 341
xuống các nhúng từ 190 202 xác thực hold-out 98–99 OpenCV 341
tải các nhúng dữ liệu đồng nhất 101 Bộ khoa học Python trên
trong các mô hình 191 vertical_flip 139 Ubuntu341
Định dạng HSV (giá trị bão hòa TenorFlow 343
Bạn tốt, Ian 305 màu sắc) 6 Theano trên Ubuntu 343
Thư viện Hyperas 264 Intel 22

GPU (đơn vị xử lý đồ họa) cài
đặt trên các phiên Hyperopt 264 kích hoạt trung gian, hình
bản AWS 350, trên AWS 346– siêu tham số tối dung 160–166 khoản
350 tổng quan 20 chọn hỗ trợ ưu hóa 263–264 tổng đầu tư vào học sâu 22–23 lệnh
66–67, thiết lập trên quan 98 điều chỉnh 114– ipython 349
115 siêu phẳng 15

không gian giả thuyết
Máy tăng cường độ 59, 72, 319 J
dốc Ubuntu 342–343 16–17 giảm
độ dốc 167 lan truyền học tính năng chung 18
Tôi
độ dốc 22 tối ưu hóa dựa trên Sổ ghi chép Jupyter 65

độ dốc 46–52 IDIA 17 định cấu hình 349–350
tổng quan 345 chạy trên
ILSVRC (ImageNet Quy mô lớn
Nhận diện hình ảnh các phiên bản GPU AWS
thuật toán lan truyền ngược 51– cài đặt Keras 350
Thách thức) 21
52 dẫn xuất, được xác phân loại hình ảnh 11 dữ thiết lập các phiên
định 47–48 độ dốc 48 giảm dần liệu hình ảnh 36–37, 319 bản GPU AWS 346–350
độ dốc ngẫu nhiên 48–51 phân đoạn hình ảnh 94
nhiệm vụ phân loại hình ảnh 262 thiết lập chuyển tiếp
ImageDataGenerator lớp 135, 139, cổng cục bộ 350
độ dốc 48 147 bằng trình duyệt cục bộ 350–
Đồ thị ma trận gram 351 bằng AWS 346
ImageNet lớp 17, 145, 281 vectơ
288, theo chu kỳ có hướng khái niệm chỉnh sửa hình ảnh
của các lớp 242–246 cho 297–298 lật 139 tạo bằng
bộ mã hóa biến thiên
Graphviz 257, 340–341 K
Graves, Alex 271 296–304 vectơ khái niệm để
lấy mẫu tham lam 272 sự chỉnh sửa ảnh 297–298 tổng K80, NVIDIA21
quan 296
thật 96 Tổng quan về nền tảng
Lớp GRU (đơn vị tái phát có Kaggle 16, 19, 266 thực
kiểm soát) 202–204, 215 hành về các vấn đề trong thế giới
thực bằng cách sử dụng 337

lấy mẫu từ các không gian tiềm Máy ảnh API 234–248
h ẩn của 296–297 khối khởi
đồ thị tuần hoàn có hướng
đầu 59 của các lớp 242–246
sao chép chữ viết tay 11 phần
Mô-đun khởi động 235, 242– khám phá 338 API chức năng
cứng 20–21 va chạm băm 183
244, 281 đối số 236–238 triển khai DeepDream
include_top 145 tắc nghẽn trong 281–286 cài đặt 343–344,
HDF5 340
thông tin 80, 84 chắt lọc thông tin 350 chia sẻ trọng số
bản đồ
lớp 246–247 mô hình dưới dạng
nhiệt kích hoạt lớp, trực quan đường ống 166 lớp 247–248 mô hình đa đầu vào
172–176 tổng quan 160 rò rỉ thông tin 97
238–240 mô hình đa đầu ra 240–
trạng thái ban đầu 196
242 chuyển đổi kiểu thần kinh
phạm vi height_shift 139 dữ liệu đầu vào 6–7, 58, trong 289–295
dữ liệu không đồng nhất 95 đối số input_shape 145
101 lớp ẩn 77 đơn vị ẩn 70 input_tensor 237 cài đặt
học biểu diễn phân cấp 8 CUDA 342 các lớp lặp lại trong 198–202 bằng
cuDNN 342 cách sử dụng lệnh gọi lại 249–259

MỤC LỤC 357
Keras framework 61–64 Mạng LeNet 15 lịch sử của 14–19

CNTK 62 đang phát triển LHC (Máy Va chạm Hadron Lớn) 17 cây quyết định 16–17
với 62–64 đang chạy 66 máy tăng cường độ dốc

TensorFlow 62 Theano 62 học tập suốt đời 333–335 16–17 phương pháp
Thư viện Keras 27 mô-đun phép biến đổi tuyến tính 72 hạt nhân 15–16 mạng thần
keras.applications 145 tổng quát hóa cục bộ, tổng kinh 14–15, 17 mô hình xác
mô-đun keras.callbacks 249, quát hóa cực trị so suất 14 khu rừng ngẫu nhiên
với 327–329 chuyển 16–17 học biểu diễn từ dữ
251 keras.preprocessing.image
135 phương thức nhân 15–16 thủ tiếp cổng cục bộ, thiết lập liệu 6–8
thuật nhân 15 K-fold xác 350 thuật toán hồi quy
thực, được lặp lại bằng cách xáo logistic 85 logreg (hồi quy người mẫu, nguy cơ biến hình
logistic) 14 log đối
trộn 99–100 Kingma, Diederik P. thành con người 325–327
298 Krizhevsky, Alex 20 số 251 tham số nhìn lại 230 dấu trang bị thừa và thiếu trang
thời gian nhìn lại 210 hàm mất phục 104–110
mát 10, 29, 58, 60, 113 mất mát thêm bỏ học 109–110 thêm
cao nguyên 250 giá trị mất mát chuẩn hóa trọng số 107–108
96 Lovelace, Ada 5 LSTM (bộ nhớ giảm kích thước mạng 104–
dài hạn ngắn hạn) 58, 202–204 tạo 107 quy trình làm việc 111–
văn bản với 271–279 tạo chuỗi dữ 115, 318–319 lắp ráp bộ
L liệu 272 lịch sử mạng thuê tuần dữ liệu 111–112 chọn giao thức
tự tạo 271 triển khai tạo văn bản đánh giá 112 chọn thước
Chính quy hóa L1 107 cấp ký tự 274–279 chiến đo thành công 112 xác định
Chính quy hóa L2 107 lược lấy mẫu 272–274 tổng quan vấn đề 111–112 phát triển
nhãn 27, 96 20, 269 mô hình 113–114
Mô hình ngôn ngữ
lớp 301 của lớp
Lambda lấy mẫu từ khóa
đào tạo 276–278 276–278
kích hoạt lớp cuối cùng 113
không gian tiềm ẩn của hình
ảnh, lấy mẫu từ tổng quan
296–297 270 khả năng
chuẩn bị dữ liệu 112–113
tương thích lớp 59 biểu
chuẩn hóa các mô hình 114–
diễn lớp đang học 8 m 115
điều chỉnh siêu tham số

học máy tự động 114–115
lớp 332–333 cách tiếp cận Xem thêm phi máy học
khả vi 332 đồ thị
cơ bản 213–215 nhánh của 94– ing
tuần hoàn có hướng của 242– 96 học tăng cường 95–96 MAE (lỗi tuyệt đối trung
246 mô-đun khởi động bình) 87, 91, 212,
242–244 kết nối còn lại 320 Thư viện Matplotlib 33, 74,
244–246
học tự giám sát 94–95 349 ma trận (tenxơ 2D) Hoạt
động tối đa 31–32 40 hoạt động
học có giám sát 94 học tổng hợp tối đa 127–129
đóng băng 150 không giám sát 94 tiền xử MaxPooling1D lớp 226,
mô hình như 247–248 lý dữ liệu 101–103 học sâu so 231 MaxPooling2D lớp 120, 122,
tổng quan 8, 58–59 với 17–18 đánh giá các mô hình 127 mean_squared_error 73 khả
lặp lại năng ghi nhớ 104 chỉ số
97–100 chọn giao thức đánh giá
trong Keras 198– 100 tập kiểm tra 97–100 tập 29 chỉ số, ghi nhật ký 249 Bộ
202 xếp chồng 217– huấn luyện 97–100 tập xác công cụ nhận thức của Microsoft.
219 giải phóng 154 thực 97–100
chia sẻ trọng lượng 246–
247 đào tạo trước theo lớp 22
Rò rỉReLU lớp 308 kỹ thuật tính năng 101–103 học Xem CNTK
LeCun, Yann 15, 17 tính năng 101–103 Mikolov, Tomas 188

358 MỤC LỤC
lô nhỏ 96 lô MSE (lỗi bình phương trung bình) dữ liệu vectơ

nhỏ SGD (giảm độ dốc ngẫu nhiên 77, 87, 91, 241, 320 phân 35 vectơ (tenxơ 1D) 31 dữ
theo lô nhỏ) 49 Bộ dữ loại nhiều lớp 78–84 mạng nhiều liệu video 37
liệu Minsky, Marvin 12 đầu 59 tối ưu hóa dựa trên độ dốc 46–
MNIST 27, 68 điểm kiểm tra mô mô hình đa đầu vào 238–240 phân 52 thuật toán lan truyền
hình 249 Lớp mô hình 162 độ loại đa nhãn 78, 96, 320 đầu vào ngược 51–52 đạo hàm 47–48 độ
sâu mô hình 8 sơ đồ mô hình đa phương thức 234 mô dốc 48 giảm dần độ dốc
258 model.fit() function 249 ngẫu nhiên 48–51
hình đa đầu ra 240–242
model.fit_generator() chức năng
249 gọi lại ModelCheckpoint
250 mô hình
N Máy ảnh 61–64
CNTK 62
N lớp 84
đang phát triển với 62–64
Thuật toán Naive Bayes 14
TenorFlow 62
ngây thơ_add 39
Theano 62
Viện tiêu chuẩn quốc gia
các mẫu kiến trúc 260– phân loại nhiều lớp 78–84
Và công nghệ.
263 chuẩn hóa
Xem NIST
hàng loạt 260–261 tích hồi quy 85–91 thiết
thuộc tính ndim 31
chập có thể phân lập máy trạm 65–67
Hệ thống Nervana 22
tách theo chiều sâu
261–263 lớp thần kinh 22 giải
GPU cho deep learning 66–
phẫu mạng thần kinh
kết nối còn lại 235– 67
236, 244–246 dưới của 58–60 lớp 58–59
Máy tính xách tay Jupyter
hàm mất mát 60 mô
dạng lớp 247–248 dưới 65 công việc đang chạy trên
hình 59–60 trình
dạng chương trình 330–332 đám mây 66 đang chạy Keras
tối ưu hóa 60 phân
xác định 191 đang phát 66 hoạt động tensor 38–45 phát
loại nhị phân 68–
triển đạt được sức mạnh sóng 39–40 dot 40–42 phần tử
77 bước đột phá trong 17 tiền khôn ngoan 38–39
thống kê 113–114
xử lý dữ liệu cho 101–102 xử
xác định dung lượng 114 tập lý các giá trị bị thiếu 102 giải thích hình học của 43–
chuẩn hóa giá trị 101–102 44
hợp 264–266 đánh giá 192–195
tối ưu hóa siêu tham số 263– giải thích hình học
264 lấy mẫu ngôn ngữ từ đào tạo học sâu 44–45 định hình
276–278 276–278 tải các lại 42–43 chuyển đổi kiểu
nhúng GloVe trong 191 học máy, thần kinh 287–295 mất nội dung 288
véc tơ hóa 101 trong Keras 289–295 mất kiểu
rủi ro nhân hóa 3 25–327 đa
đầu vào 238–240 đa đầu ra 240– biểu diễn dữ liệu cho 31–37 288–289
242 chuẩn hóa 114–115 đào tạo

192–195 sử dụng Keras gọi tenxơ 3D 32 lô
N-gam 180
dữ liệu 34–35
lại 249–259 sử dụng TensorBoard NIST (Viện quốc gia về
249–259 chương trình con ví dụ về tenxơ dữ liệu 35 tiêu chuẩn và
mô-đun, sử dụng lại 333–335 Công nghệ) 27 hàm
tenxơ chiều cao hơn 32 phi tuyến tính 72 phi máy
học, đường cơ sở 212–213
dữ liệu hình ảnh 36– vấn đề không cố định
37 các thuộc tính chính của 111 chuẩn hóa lô 260–261 chuẩn
tensor 32–33 thao tác
hóa giá trị 101–102
với tensor trong
Numpy 34 ma Mảng NumPy 28, 31
trận (tenxơ 2D) 31–32 Thư viện Numpy, thao tác tensors
vô hướng (tenxơ 0D) trong 34
mô-đun, khởi động 242–244 xung 31 dữ liệu chuỗi 35–36 dữ Ma trận numpy 31
lượng 50 liệu chuỗi thời gian 35–36 Tenxơ NumPy 53
Định luật Moore 21, 317 NVIDIA20, 66

MỤC LỤC 359
Ô tổng quan 135–138 mạng thần kinh định kỳ 196–
nhúng 190–191 kết nối 224, 319, 321–322 phương
phát hiện đối tượng 94 được đào tạo trước 143–159 trích pháp học máy cơ bản 213–215 hai
hàm mục tiêu 10, 60 xuất tính năng 143–152 với tăng chiều 219–222 kết hợp với
Nguyên tắc dao cạo của Occam 107 kết nối 228–231 cơ sở định kỳ
cường dữ liệu 149–152 không
quãng tám 281–282 mã hóa một lần đầu tiên 215–216 tổng quát,
tăng cường dữ liệu 147–
nóng các ký tự 181–183 từ 181– lịch sử 271
149 tinh chỉnh 152–158 với bộ
183 tổng quan 79, 84, 101 tài
dữ liệu nhỏ 159
liệu trực tuyến, tối ưu hóa
Keras 338 22, 50, 104, 113,
263–264 Lớp GRU 202–204
mạng được huấn luyện trước 130,
Các lớp LSTM 202–204
143 nhúng từ được huấn luyện
đường cơ sở không học máy
trước 184 212–213 chuẩn bị dữ
đối số trình tối ưu hóa 11, 29, 58, mô hình xác suất 14 phân bố liệu cho các lớp lặp lại 210–
73 trình tối ưu hóa 60 lớp xác suất 80 bài toán, xác định 212 trong Keras 198–202 xếp
đầu ra 77 tổng quan 95 tensor 237 trình tự xử lý 111–112 với các chồng các lớp lặp lại 217–
overfitting thêm dropout 109–110 kết nối 225–231 219 bằng cách sử dụng bỏ học
thêm điều chỉnh trọng số 107–108 lặp lại để chống lại việc
giảm kích thước mạng 104–107 sử
Tích chập 1D cho dữ liệu chuỗi trang bị thừa 216–217
dụng dropout lặp lại để chống
225–226
lại 216–217
Tổng hợp 1D cho dữ liệu chuỗi 226
Các lệnh gọi lại của ReduceLROnPlateau
250–251
kết hợp với các mạng thần
hồi quy 60, 85–91, 320 hàm
kinh hồi quy để xử lý các
mất chính quy hóa 300 mô hình
chuỗi dài 228–231
chính quy hóa 114–115
học tăng cường 95–96 relu (đơn vị

triển khai kết nối 1D 226–227
tuyến tính chính quy) 71 biểu diễn
trích xuất 28 tổng quan 6
P chương trình con chương trình
334 tổng hợp chương trình 331
đệm 125–126 lớp được Thư viện pydot

tham số hóa 10 điều chỉnh PyCharm 65 257 pydot- định hình lại các tenxơ 42–
tham số 249 tổng quan 97 ng 341 43 kết nối còn lại 235 bản
phân vùng 99 lệnh Python đồ phản hồi 124 đối số
passwd() 349
cài đặt bộ khoa học trên return_sequences 198 khả năng
Tổng quan về tái sử dụng 23 phân
Ubuntu 341 19 gói biệt chế độ đảo ngược

PCA (phân tích thành phần
python-pip 341
chính) 255 52
Pichai, Sundar 22
Định dạng RGB (đỏ-lục-lam) 6
pip 350 plot_model Hỏi
Trình tối ưu hóa RMSProp 53, 73,
258 mã đồ thị 156 77, 135, 155, 222
tích chập theo chiều mô hình trả lời câu hỏi 238
RNN (mạng nơ-ron tái phát)
điểm 243 gộp 1D, cho dữ liệu
196 rotate_range
chuỗi 226 phương pháp dự đoán 76,
83, 147 lỗi dự đoán 95–96
r 139
dự đoán 83 chuẩn bị dữ liệu 112–

rừng ngẫu nhiên 16–17
113 tiền xử lý dữ liệu 101–103, S
xáo trộn dữ liệu ngẫu nhiên
135–138 cho mạng lưới thần kinh
100 ngẫu nhiên 272 xếp hạng 31
101–102 mẫu trục 34 mẫu
chiều 34 lấy mẫu từ các
bỏ học định kỳ 207, 216 lớp mô hình ngôn ngữ 276–278
định kỳ, hai chiều 207

360 MỤC LỤC
lấy mẫu (tiếp theo) từ softmax 28, 80, 84, 273, 320 dữ định hình lại
các không gian tiềm ẩn của hình liệu âm thanh 319 42 cắt lát 34
ảnh 296–297 chiến lược thưa_categorical_crossentropy 83–84 Xem thêm bộ kiểm tra
272–274 độ căng dữ liệu 97–100
Sanity Preserver, arXiv 338 các mẫu phân cấp theo không gian xác thực giữ lại 98–99 lặp
hồi quy vô hướng 86, 96 tensor 123 nhận dạng giọng nói lại xác thực K-fold với xáo
vô hướng 31 scalars (tensors 11 thư mục ssl 348 xếp chồng các trộn 100
0D) 31 triển khai sơ đồ, của lớp lặp lại 217–219 sức mạnh Xác thực K-fold 99 dữ
thống kê, phát triển các mô hình liệu văn bản 180–195, 319
GÂN 307 với 113–114
tải xuống văn bản thô
Schmidhuber, Jürgen 202 188–195
Scikit-Tìm hiểu 63 mã hóa một lần các từ và ký
SciPy 284, 341 step_per_epoch 136 giảm tự 181–183
học tự giám sát 94–95 chức năng độ dốc ngẫu nhiên.

selu 261 Xem SGD
nhúng từ 184–195 xác định các
Lớp Conv2D có thể tách rời 261, lấy mẫu ngẫu nhiên 272 ngẫu mô hình 191 tải xuống các
321 nhiên 272, 308 tích chập nhúng từ GloVe 190 học với
có bước 127 bước tiến 125
siêu phẳng phân tách 15 tạo các lớp nhúng 185–187 tải
hàm kiểu 288 mất kiểu 288–
dữ liệu trình tự 272 tổng các nhúng GloVe trong mô
quan 35–36 tạo trình tự 94 289 chương trình con, sử hình 191 tiền xử lý 190–
dự đoán trình tự 60 trình dụng lại mô-đun 333–335 học 191 đào tạo trước 188 mã hóa
tự, xử lý với convnets 225–231 có giám sát 94 dữ liệu 189–190 đào tạo và
đánh giá mô hình 192–195 văn

bản, tạo bằng LSTM 271 –279
SVM (máy vector hỗ trợ) 15 tạo dữ liệu trình tự 272 lịch
Tích chập 1D cho dữ liệu chuỗi sử của các mạng thuê định kỳ
225–226 ký hiệu AI 4, 12 tạo 271 triển khai tạo văn
Tổng hợp 1D cho dữ liệu phân biệt ký hiệu 52 dự đoán bản cấp ký tự 274–279 chiến lược
chuỗi 226 cây cú pháp 94 lấy mẫu 272–274 chuyển đổi
kết hợp với các mạng thần Szegedy, Christian 235 văn bản thành giọng nói 12
kinh hồi quy 228–231
triển khai các kết nối t
1D 226–227
kích hoạt tanh 77
Lớp tuần tự 63, 248 mục tiêu

Mô hình tuần tự 150, 234 95 rò rỉ thời gian
SGD (giảm độ dốc ngẫu nhiên) 100 học tập được giám sát tạm thời
48–51, 60 học nông 8 95 Cài đặt
chia sẻ LSTM 247 shear_range Ứng dụng TensorBoard 233, 249–259 Theano trên Ubuntu 343 tổng
139 tùy chọn show_shapes 258 quan 23, 62 dữ liệu chuỗi
xáo trộn, xác thực K-fold lặp Khung trực quan hóa thời gian 35–36, 319 dấu thời
lại với 100 TensorFlow 252–258 gian 210
tenxơ TITAN X, mã thông báo
thuộc tính khóa 32 chiều NVIDIA 21 nhúng 180 dữ
Siamese LSTM model 247 hàm cao hơn của 32–33 thao liệu mã thông báo, từ
sigmoid 71, 86, 320 tác trong Numpy 34 thao tác nhúng 189–190 tổng tổn
Simonyan, Karen 143 của 38–45 thất biến thể 291
Lớp SimpleRNN 198, 322 phân phát sóng 39–40 dot 40– TPU (đơn vị xử lý tensor) 21
loại theo nhãn đơn 320 phân 42 phần tử khôn ngoan
loại đa lớp 78 38–39 thuộc tính có thể huấn luyện 150
giải thích hình học của 43– huấn

cửa sổ trượt 124 44 luyện convnets trên các tập
Tính năng Smart Reply, Google giải thích hình học dữ liệu nhỏ 130–142 xây
271 smile vector 297 về học sâu 44–45 định hình dựng mạng 133–135
lại 42–43

MỤC LỤC 361
đào tạo, kết nối trên tập dữ chỉnh sửa 297–298 nhúng từ 184–195 xác định các
liệu nhỏ (tiếp theo) lấy mẫu từ các khoảng trống mô hình 191 tải xuống các
tiền xử lý dữ liệu của hình ảnh 296–297 nhúng từ GloVe 190 đánh giá
135–138 tải xuống điểm xác thực 100 bộ xác thực 97– các mô hình 192–195
dữ liệu 131–133 mức 100 xác thực giữ lại 98–99 xác tìm hiểu các lớp nhúng 185–187
độ liên quan đối thực K-fold lặp lại với xáo
với dữ liệu nhỏ trộn 100
sự cố 130–131 khi sử tải GloVe nhúng trong các mô

Xác thực K-fold 99 hình 191
dụng tăng dữ liệu 138–142
overfit 97 tổng nhúng tiền xử lý 190–191 mã
quan 73 đối số hóa dữ liệu 189–190 mô
ngắt 249 mô hình
ngôn ngữ 276–278 mô hình 192– validation_data 74, 137 đối số hình đào tạo 192–195 sử dụng
195 vòng huấn luyện 11, 46 verify_steps 137 giá trị
nhúng từ được đào tạo trước
tập huấn luyện 97–100 xác thực 188 vectơ từ 184
giữ lại 98–99 lặp lại xác thực
K-fold với xáo trộn 100 xử lý thiếu 102 bình
thường hóa 101–102 vấn Thuật toán Word2vec 188
đề độ dốc biến mất 202 không gian nhúng từ 185
Xác thực K-fold 99 word_index 69 quy trình làm
biến train_labels 27, 68 mẫu Vapnik, Vladimir 15 dữ việc của máy học 111–115, 318–319
liệu véc tơ 35, 319 lắp ráp bộ dữ liệu 111–
bất biến dịch mã 123, 321 chuyển
vị 43 hồi quy véc tơ 96 véc 112 chọn giao thức đánh giá 112
tơ hóa 101 dữ liệu véc
chọn thước đo thành công 112
tơ hóa 69 triển khai xác định vấn đề 111–112
Phép thử Turing 5
véc tơ hóa 38 véc tơ hóa văn bản phát triển mô hình 113–114 chuẩn
Turing, Alan 5
mạng hai nhánh 59 180 véc tơ (tenxơ 1D) 31 tính linh bị dữ liệu 112–113 chuẩn
hoạt 23 vi 350 dữ liệu video 37, hóa các mô hình 114–115 siêu
Tyka, Mike 280, 306
319 khái niệm trực quan 160 trực tham số điều chỉnh 114–115 quy
quan hóa bộ lọc convnet 167–172
trình công việc 18 máy trạm,
bạn
học tập convnet 160 –176 bản đồ
thiết lập 65–67
nhiệt kích hoạt lớp 172–176 kích
Ubuntu
hoạt trung gian 160–166 dữ liệu
cài đặt Keras trên 343–344 cài thể tích 319
đặt bộ khoa học Python trên 341
Máy tính xách tay Jupyter

cài đặt Theano trên 343
65 chạy tác vụ trên đám mây
thiết lập hỗ trợ GPU 342–343
66 chạy Keras 66 chọn GPU
trang bị thiếu 104–110
66–67 viết lệnh gọi lại 251–
thêm phần bỏ học 109–110 thêm
252
điều chỉnh trọng lượng 107–
108 giảm kích thước mạng 104–107
W X
phân rã trọng lượng
Ngoại lệ 244, 248
107 chính quy hóa trọng
giải phóng các lớp 154 Thư viện XGBoost 19, 337
số, thêm 107–108
máy trạm Unix 65
chia sẻ trọng số của các
học không giám sát 94 lớp 246–247 lược Y
đồ khởi tạo trọng số 22
V toán tử năng suất 136
đối số trọng số, trọng số VGG16

VAE (bộ mã hóa tự động biến 58, 145, lớp 10 z
đổi), tạo hình ảnh với
296–304 vectơ khái niệm Welling, Tối đa 298 Zisserman, Andrew 143
cho hình ảnh phạm vi width_shift 139 zoom_range 139

CÁC TIÊU ĐỀ LIÊN QUAN
Học máy với TensorFlow của Nishant

Shukla ISBN: 9781617293870 325 trang,
$44,99 Tháng 12 năm 2017
Cuốn sách Quick Python, Phiên bản thứ ba

của Naomi Ceder
ISBN: 9781617294037
400 trang, $39,99

Tháng 12 năm 2017
R trong hành động, Phiên bản thứ
hai Phân tích dữ liệu và đồ họa với R

của Robert I. Kabacoff
ISBN: 9781617291388 608
trang, $59,99 Tháng 5

năm 2015
Khoa học dữ liệu thực tế với R
của Nina Zumel và John Mount

ISBN: 9781617291562 416 trang,
$49,99 Tháng 3 năm 2014
Để biết thông tin đặt hàng, hãy truy cập www.manning.com

PYTHON/MÁY HỌC
Học sâu với Python

François Chollet XEM CHÈN
Máy học đãChúng

năm. có những tiến bộ
tôi đã chuyển đángdạng
từ nhận kể giọng
trongnóithời gian
và hình ảnh gần
gần đây
như không sử dụng được sang độ chính xác gần như con người. Chúng
“Lời giải thích rõ ràng
tôi đã đi từ những cỗ máy không thể đánh bại một kỳ thủ cờ vây nghiêm túc
nhất về deep learning tôi đã đến
”
đến việc đánh bại một nhà vô địch thế giới. Đằng sau sự tiến bộ này là
học sâu—sự kết hợp của các tiến bộ kỹ thuật, các phương pháp hay nhất và ngang qua ... đó là một niềm vui để đọc.
lý thuyết cho phép tạo ra vô số ứng dụng thông minh không thể thực hiện —Richard Tobias, Cephasonics
được trước đây.
“Một tiêu đề giới thiệu

Deep Learning với Python giới thiệu lĩnh vực deep learning sử
dụng ngôn ngữ Python và thư viện Keras mạnh mẽ. thực hành xuất sắc, có
Được viết bởi người sáng tạo Keras và nhà nghiên cứu AI của Google ,
François Chollet, cuốn sách này giúp bạn hiểu rõ hơn thông qua các giải thích
chiều sâu và chiều rộng lớn.
—David Blumenthal-Barby
”
Babbel
trực quan và ví dụ thực tế. Bạn sẽ khám phá các khái niệm đầy thách thức và
thực hành với các ứng dụng trong thị giác máy tính, xử lý ngôn ngữ tự nhiên
và các mô hình tổng quát. Khi hoàn thành, bạn sẽ có kiến thức và kỹ năng thực “Thu hẹp khoảng cách giữa
hành để áp dụng deep learning vào các dự án của riêng mình.
sự cường điệu và một hệ
thống học sâu đang hoạt động.
—Peter Rabinovitch, Akamai
”
Có gì bên trong
• Học sâu từ các nguyên tắc đầu tiên • Thiết “Tài nguyên tốt nhất để
lập môi trường học sâu của riêng bạn • Các mô hình phân loại
trở thành bậc thầy về
hình ảnh • Học sâu cho văn bản và trình tự • Chuyển kiểu thần
kinh, tạo văn bản và tạo hình ảnh

Keras và deep learning.
—Claudio Rodriguez
”
Cox Media Group
Người đọc cần có kỹ năng Python trung cấp. Không cần có kinh nghiệm trước
đó với Keras, TensorFlow hoặc máy học.
François Chollet là nhà nghiên cứu AI trong Nhóm Google Brain và là tác
giả của thư viện học sâu Keras.
Để tải xuống Sách điện tử miễn phí của họ ở định dạng PDF, ePub và
Kindle, chủ sở hữu của cuốn sách này nên truy cập
www.manning.com/books/deep-learning-with-python
QUẢN LÝ $49,99 / Có thể $ 65,99 [BAO GỒM SÁCH ĐIỆN TỬ]

Tóm tắt chương: 177 Hình dung những gì convnets học

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Tóm tắt chương: 177 Hình dung những gì convnets học

Uploaded by

Copyright:

Available Formats

Machine Translated by Google

Hình dung những gì convnets học 177

Tóm tắt chương Convnets

để đại diện cho thế giới thị giác.

vấn đề phân loại hình ảnh.

như bản đồ nhiệt của hoạt động trong lớp.

Được cấp phép cho <null>

Học sâu cho văn

Chương này bao gồm

Tiền xử lý dữ liệu văn bản thành các biểu

thần kinh hồi quy Sử dụng các convnets 1D để

hai cách tiếp cận này trong chương này.

Được cấp phép cho <null>

hay tiêu cực

tion, đưa ra dữ liệu thời tiết gần đây

Được cấp phép cho <null>

180 CHƯƠNG 6 Học sâu cho văn bản và trình tự

6.1 Làm việc với dữ liệu văn bản Văn bản

từ hoặc ký tự và biến đổi mỗi n-gam thành một vectơ.

mà bạn có thể gửi tới mạng Keras.

bản "Con mèo ngồi trên chiếu."

"the", "cat", "sat", "on", "the", "mat", "."

Mã hóa vectơ của mã thông báo 0,0

Được cấp phép cho <null>

Làm việc với dữ liệu văn bản 181

Tìm hiểu về n-gam và từ loại n-gam Từ n-gam

{"The", "The cat", "cat", "cat sat", "sat",

6.1.1 Mã hóa một lần các từ và ký tự

Được cấp phép cho <null>

182 CHƯƠNG 6 Học sâu cho văn bản và trình tự

Liệt kê 6.1 Mã hóa one-hot cấp độ từ (ví dụ về đồ chơi)

Mã thông báo các mẫu thông qua phương

nhập numpy dưới dạng np

token_index = {} cho mẫu

trong mẫu: cho từ trong mẫu.split():

nếu từ không có trong token_index:

results = np.zeros(shape=(len(samples), max_length,

max(token_index.values()) + 1)) for i, sample in

đối với j, từ trong danh sách(enumerate(sample.split()))[:max_length]:

index = token_index.get(word) results[i, j,

Gán một chỉ mục duy nhất cho mỗi từ

Liệt kê 6.2 Mã hóa one-hot cấp ký tự (ví dụ về đồ chơi)

token_index = dict(zip(range(1, len(characters) + 1), characters))

max_length = 50 kết quả

= np.zeros((len(samples), max_length, max(token_index.keys()) + 1)) for i, sample in enumerate(samples):

đối với j, ký tự trong kiểu liệt kê(mẫu): index =

token_index.get(character) results[i, j, index] = 1. Tất cả các ký tự ASCII

Được cấp phép cho <null>

Làm việc với dữ liệu văn bản 183

Liệt kê 6.3 Sử dụng Keras để mã hóa one-hot cấp độ từ

Tạo mã thông báo, được định cấu hình

từ keras.preprocessing.text nhập Tokenizer nhất

trình tự = tokenizer.texts_to_sequences(mẫu) sách các chỉ số nguyên

word_index = tokenizer.word_index print('Đã tìm thấy

%s mã thông báo duy nhất.' % len(word_index))

chiều = 1000 max_length = 10

results = np.zeros((len(samples), max_length, dimensions)) for i, sample in enumerate(samples):

đối với j, từ trong danh sách(enumerate(sample.split()))[:max_length]: index = abs(hash(word))

Băm từ thành một chỉ số

Được cấp phép cho <null>

184 CHƯƠNG 6 Học sâu cho văn bản và trình tự

6.1.2 Sử dụng nhúng từ

Hình 6.2 Trong khi các biểu diễn từ thu được từ