Tony Deep’s Blogs

Blogging with Jupyter Notebooks

2020-04-12T00:00:00+00:00

With Notebooks, we can easily share prose, code, tables, charts, and more!

Writing your notebook
Exporting to markdown

Jupyter Notebooks is a great environment for creating blog posts. Or maybe you didn’t even plan to write a blog post, but you’ve done some interesting experiments and you realize afterwards that you have results worth sharing. Either way, you’ll want some way to get your Notebook onto your blog.

fast_template and nbdev are set up to handle Jupyter Notebooks nicely, so there’s not much you have to do to get this working. I’ll walk you through the steps here. Note that Jupyter Notebooks and GitHub Pages already have some support for exporting notebooks to markdown; but I suggest you use fast_template and nbdev, with the process described in this post, because otherwise you won’t get useful features such as:

Support for pasting images directly into your notebook
Input and output cells clearly displayed with appropriate styles
The ability to hide some cells from the markdown output.

This whole post was created using this method. You can see the source notebook here:

Writing your notebook

Your markdown cells, code cells, and all outputs will appear in your exported blog post. The only thing that won’t be shown is interactive outputs (e.g. ipywidgets, bokeh plots, etc), or cells you explicitly hide using the #hide marker discussed below.

When you write your notebook, just write whatever you want your audience to see. Since most writing platforms make it much harder to include code and outputs, many of us are in a habit of including less real examples than we should. So try to get into a new habit of including lots of examples as you write.

Often you’ll want to hide boilerplate such as import statements. Add #hide to the top of any cell to make it not show up in output.

Jupyter displays the result of the last line of a cell, so there’s no need to include print(). (And including extra code that isn’t needed means there’s more cognitive overhead for the reader; so don’t include code that you don’t really need!)

1+1

It works not just for text, but also for images:

Image.open('../fast.ai/images/fast_template/image2.png').flip_lr()

…and plots:

plt.plot([1,2]);

…and Pandas DataFrames, and much more!

pd.DataFrame({'a':[1,2], 'b':[3,4]})

	a	b
0	1	3
1	2	4

You can also paste images, such as screenshots, directly into a markdown cell in Jupyter. This creates a file embedded in the notebook that Jupyter calls an “attachment”. Or you can use Markdown to refer to an image on the internet by its URL.

Exporting to markdown

Before you export to markdown, you first need to make sure your notebook is saved, so press s or click File➡Save. Then close the browser tab with the open notebook. This is important, because when we export to markdown any attachments will be exported to files, and the notebook will be updated to refer to those external files. Therefore, the notebook itself will change; if you leave it open, you may accidentally end up overwriting the updated notebook.

You’ll need nbdev installed; if you haven’t already, then install it with:

pip install nbdev

Then, in your terminal, cd to the folder containing your notebook, and type (assuming your notebook is called name.ipynb):

nbdev_nb2md name.ipynb

You’ll see that a file name.md and folder name_files have been created (where “name” is replaced by your notebook file name). One problem is that the markdown exporter assumes your images will be in name_files, but on your blog they’ll be in /images/name_files. So we need to do a search and replace to fix this in the markdown file. We can do this automatically with python. Create a file called upd_md.py with the following contents:

import fileinput,re
for f in fileinput.input(inplace=True):
    print(re.sub(r'^(!.*]\()(\w+_files/)', r'\1/images/\2', f), end='')

Then, in the terminal, run (assuming that upd_md.py and your markdown doc are in the same folder):

python upd_md.py name.md

This will modify your markdown doc inplace, so it will have the correct /images/ prefix on each image reference.

Finally, copy name_files to the images folder in your blog repo, and name.md to your _posts folder, and rename name.md to have the required YEAR-MONTH-DAY-name.md format. Commit and push this to GitHub, and you should see your post!

Hàm Scan trong Tensorflow

2017-08-09T00:00:00+00:00

Hàm scan là một một trong những hàm quan trọng trong Theano và giờ đây đã được Tensorflow sử dụng bởi sự tiện lợi và linh hoạt của nó.

Overview
Formular
Example 1: Hard code
Example 2: Learning to predict the Sum
Discussion
Conclusion

Overview

Hàm Scan cho phép bạn sử dụng vòng lặp trong Đồ thị tính toán (computation graph) của Tensorflow, cho phép bạn sử dụng thuật toán lan truyền ngược (backpropagation) và một số kỹ thuật khác trong Machine Learning. Trong Tensorflow bạn có thể định nghĩa k nodes mới cho vòng lặp có k steps. Tuy nhiên giá trị k sẽ cố định thay vì được tuỳ chỉnh mềm dẻo và việc này làm cho đồ thị tính toán của bạn trở nên chậm chạp hơn rất nhiều.

Formular

tf.scan(fn, elems, initializer=None, parallel_iterations=10, back_prop=True, swap_memory=False, name=None)

Toán tử Scan áp dụng lặp đi lặp lại hàm fn trên chuỗi các thành phần elems từ trái sang phải. Các thành phần này được tạo nên từ các tensor được unpack từ elems theo chiều (dimension) 0. Hàm khả gọi fn nhận vào 2 đối số là 2 tensor: Tensor thứ nhất là giá trị tích luỹ được tính từ lời gọi hàm fn tại bước ngay trước. Nếu initializer = None, elems phải chứa ít nhất 1 phần tử và phần tử đầu tiên sẽ được sử dụng như là phần tử khởi tạo initializer.

Giả sử elems được giải nén thành tensor values là list của các tensor, hàm fn sẽ trả về tensor có định dạng shape = [len(values)] + fn(initializer, values[0]).shape

Tham số:

fn: Hàm áp dụng.
elems: Tensor có thể unpack theo chiều (dimension) 0.
initializer: (optional) Giá trị khởi tạo.
parallel_iterations: (optional) Số bước lặp cho phép chạy song song.
back_prop: (optional) True cho phép back propagation.
swap_memory: (optional) True cho phép hoán đổi việc sử dụng GPU-CPU memory.
name: (optional) Name prefix for the returned tensors.

Kết quả:

Một Tensor được nén các kết quả trung gian áp dụng hàm fn trên list các tensors giải nén từ elems, theo thứ tự từ trái sang phải.

Ví dụ

elems = [1, 2, 3, 4, 5, 6]
sum = scan(lambda a, x: a + x, elems)
#=> sum == [1, 3, 6, 10, 15, 21]

Nào hãy cùng phân tích 2 ví dụ đơn giản để hiểu rõ hơn cách sử dụng Scan trong Tensorflow:

Ví dụ 1: Viết một chương trình tính tổng luỹ tích của một list sử dụng scan.

Input : [1, 2, 2, 2]

Output: [1, 3, 5, 7]
Ví dụ 2: Sử dụng RNN để giải quyết Ví dụ 1 bằng cách train RNN để dự đoán chuỗi output [1, 3, 5, 7] từ chuỗi input đã biết [1, 2, 2, 2].

Example 1: Hard code

Output: [ 1.  3.  5.  7.]

Ví dụ trên là cách đơn giản để sử dụng Scan. Vậy thực sự Scan làm việc như thế nào trong Tensorflow: Scan duyệt qua lần lượt từng phần tử trong elems, tại mỗi vị trí k sẽ áp dụng hàm fn với inputs là output của bước trước đó k-1 và input của bước hiện tại. Giá trị tại bước k = 0 được gán khởi tạo trong initializer:

Lặp 0: fn(0.0, 1.0) == 1.0
Lặp 1: fn(1.0, 2.0) == 3.0
Lặp 2: fn(3.0, 2.0) == 5.0
Lặp 3: fn(5.0, 2.0) == 7.0

Dòng 6: elems = tf.identity(elems): Sử dụng để fix lỗi ở đây.

Không sử dụng hàm tf.identity(): Trong ví dụ trên, ta muốn tính cộng thêm 1 và giá trị của biến x tại dòng 5 sau mỗi lần y được kiểm tra để in ra ở dòng 11. Tuy nhiên:

Kết quả là: 0.0, 0.0, 0.0, 0.0, 0.0

Vấn đề được giải quyết bằng cách sử dụng tf.identity() như ở code dưới đây:

Sử dụng hàm tf.identity():

Kết quả là: 1.0, 2.0, 3.0, 4.0, 5.0

Example 2: Learning to predict the Sum

Ở ví dụ này, chúng ta sẽ viết một chương trình sử dụng mô hình RNN (Recurrent Neural Network) và huấn luyện (train) mô hình để dự đoán hàm sum từ tập dữ liệu huấn luyện (training data).

Importing libs

Generating Inputs and Targets

Trước hết chúng ta sẽ sinh training data là các cặp chuỗi input và chuỗi target tương ứng (được dùng như là những vector cột shape=[k, 1])

Defining the RNN Model from Scratch

Tiếp theo, định nghĩa RNN model. Code tuy có hơi dài nhưng cơ bản với những comment giải thích bên trong sẽ giúp bạn dễ dàng hiểu và thực hành hơn.

Các thành phần chính của RNN như sau:

Trạng thái (state) của RNN được update bởi công thức:

$h_{t}=tanh( W_{h}h_{t-1}+W_{x}x_{t}+b)$

_vanilla_rnn_step là thành phần chính của mô hình RNN này: Nó áp dụng công thức trên bằng việc nhận đầu vào là trạng thái của bước trước cùng với input hiện tại và sinh ra trạng thái mới. Có một chút bối rối ở đây khi các bạn phải xử lý shape của các tensor bằng cách chuyển vị (transpose) sao cho phù hợp với việc tính toán và yêu cầu của Tensorflow.
_compute_predictions áp dụng _vanilla_rnn_step cho mọi bước sử dụng scan, mỗi bước cho kết quả là một trạng thái mới, sau đó sử dụng một layer để biến shape của trạng thái thành shape của target và dự đoán kết quả.
_compute_loss tính khoảng cách Euclid trung bình (mean squared Euclidean distance) giữa target thực tế và kết quả dự đoán được.

Defining an Optimizer

Chúng ta tiếp tục định nghĩa lớp Tối ưu hoá (Optimizer). Trong lớp này chúng ta sẽ sử dụng thuật toán gradient descent để update mô hình, sử dụng kỹ thuật cắt ngọn (gradient clipping) để tránh việc bùng nổ gradient (exploding gradient), bằng cách sử dụng ngưỡng max_global_norm - Khi đó tại mỗi bước tính toán gradient, mỗi khi global norm (tổng norm của tất cả gradients) vượt quá ngưỡng sẽ được chuẩn hoá thành max_global_norm.

Training

Mọi thứ đã sẵn sàng, chúng ta tiến hành định nghĩa và thực thi hàm train, tại đây chúng ta sẽ thực hiện các bước tính toán và update tham số của mô hình, và ghi nhận lại thông tin của của mô hình để có thể quan sát một cách trực quan thông qua công cụ TensorBoard của Tensorflow. Mô hình đươc train như sau: Sau khi train mô hình, chạy lệnh tensorboard --logdir ./logdir, vào địa chỉ http://localhost:6006 để quan sát các thông số của mô hình: loss, biểu đồ train mô hình qua từng steps, mô hình trực quan, …

Testing Qualitatively

Cuối cùng chúng ta tiến hành kiểm tra chất lượng của mô hình bằng cách vẽ chuỗi target và chuỗi dự đoán trên cùng một biểu đồ, nếu 2 chuỗi có xu hướng chồng lên nhau thì mô hình cơ bản là tốt, ngược lại nếu 2 chuỗi tách biệt nhau thì mô hình dự đoán yếu.

và chạy:

test_qualitatively(sess, model, generator, figsize=(8, 2))

Kết quả như sau:

Discussion

Vậy là các bạn đã hoàn thiện một chương trình RNN đơn giản để huấn luyện mô hình dự đoán chuỗi tổng luỹ tích từ chuỗi input cho trước. Một số phần các bạn có thể lưu ý để cải thiện mô hình tốt hơn:

Giá trị của hidden_layer_size, trong mô hình trên chúng ta gán hidden_layer_size = 256. Các bạn hãy thử với các giá trị nhỏ hơn (mỗi lần chia cho 2) và quan sát loss.
Giá trị của initial_learning_rate=1e-2. Hãy thử với các giá trị khác và quan sát loss.
Giá trị cho gradient clipping max_global_norm=1.0. Hãy thử train mô hình mà không sử dụng gradient clipping, cùng đó kết hợp với lựa chọn initial_learning_rate phù hợp.

Conclusion

Mô hình trên được huấn luyện tại mỗi bước cho sử dụng duy nhất 1 cặp chuỗi input và target. Việc này làm tăng thời gian huấn luyện mô hình. Cải thiện bằng cách có thể sử dụng input_size lên tuỳ thuộc vào cấu hình máy.
Mô hình trên sử dụng chỉ một layer, chúng ta có thể mở rộng thành deep model bằng cách chồng thêm 1, 2, … các layer lên nhau: Thực hiện hàm scan để lấy kết quả layer thứ nhất, chạy scan lần thứ hai để lấy kết quả của layer thứ 2, cứ tiếp tục như vậy. Lưu ý: Output của layer l sẽ là input của layer l+1.
Mô hình RNN cơ bản này ít khi sử dụng gần đây do hai vấn đề của nó là triệt tiêu và bùng nổ gradient (<a href=”“https://en.wikipedia.org/wiki/Vanishing_gradient_problem>vanishing và expoding gradient</a>). Hai mô hình thay thế cho RNN hay được sử dụng là LSTM (Long-Short Term Memory) và GRU (Gated Recurrent Unit).
Chúng ta đang sử dụng thuật toán BPTT (backpropagation through time) đầy đủ bằng cách thực hiện toàn bộ quá trình lan truyền xuôi, ngược cho mỗi lượt update gradietn. Việc này làm cho quá trình train mô hình của chúng ta trở nên chậm, tốn thời gian. Một kỹ thuật thay thế là sử dụng truncated backpropagation through time bằng cách cập nhật thông tin của mô hình thông qua một khoảng thời gian gần hơn trong quá khứ tuy vậy vẫn đảm bảo giữ được thông tin xa hơn quá khứ vì chúng cũng được lưu lại trong các trạng thái.

Cross-Entropy Loss là gì?

2017-07-07T00:00:00+00:00

This post reviews some extremely remarkable results in applying deep neural networks to natural language processing (NLP)

Contents
Introduction
Entropy
Cross Entropy
- Tại sao cross-entropy lại quan trọng ???
KL Divergence - KL phân kỳ
Khả năng dự đoán
Likelihood
Thảo luận
Nguồn tham khảo

Introduction

Giai thoại Neumann-Shannon (From Hmopedia)

Mục tiêu của bài toán phân lớp dựa trên tính toán xác suất (Probabilistic classification) là gán (map) dữ liệu đầu vào cho nhãn của lớp có xác suất cao nhất, và chúng ta thường train mô hình bằng điều chỉnh tham số của mô hình sao cho xác suất dự đoán được càng sát với ground-truth probabilities càng tốt.

Chúng ta giả sử chỉ xét mô hình với nhãn các lớp là phân biệt. Ví dụ cho bài toán phân lớp ảnh số từ $0-9$ MNIST database với input là danh sách các ảnh và output là $10$ số từ $0-9$ , mô hình sẽ dự đoán xác suất output (cho mỗi ảnh input tương ứng) là danh sách $10$ số mỗi số là xác suất mà ảnh đầu vào sẽ thuộc lớp tương ứng, và thoả mãn: $\sum_{k=0}^9\hat{y}_k = 1.0$

Trong quá trình training, giả sử chúng ta có ảnh input là ảnh mang số $9$ và mô hình được kỳ vọng sẽ dự đoán xác suất đầu ra gần với ground-truth class probability $y = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0)^T$ , nghĩa là xác suất tại vị trí số $9$ của output $y$ đạt $max$ . Giả sử mô hình dự đoán phân bố xác suất output khác biệt so với target $y$ , với $\hat{y} = (0.0, 0.0, 0.0, 0.0, 0.0, 0.1, 0.1, 0.4, 0.3, 0.1)$ , thì chúng ta sẽ phải điều chỉnh tham số của mô hình sao cho $\hat{y}$ tiến gần tới $y$ .

Vậy thế nào là điều chỉnh tham số cho $\hat{y}$ tiến gần tới $y$ . Ở đây nghĩa là chúng ta sẽ tìm cách đánh giá sự khác biệt giữa $\hat{y}$ và $y$ .

Có nhiều cách để đánh giá sự khác biệt này, ở post này chúng ta sẽ đi tìm hiểu một trong số những cách phổ biến nhất đó chính là cross-entropy, và đánh giá tại sao cross-entropy lại phù hợp cho bài toán phân lớp (classification).

Entropy

Claude Shannon

Code, Codeword, Encode-Decode

Các bạn hẳn vẫn còn nhớ cô nàng Alice và anh chàng Bob trong những câu chuyện về an toàn bảo mật thông tin. Lần này câu chuyện của 2 bạn ấy như sau: Bob rất thích động vật, anh ấy có thể nói chuyện cả ngày với Alice về chủ đề động vật. Đặc biệt khi nói chuyện với Alice anh ấy luôn chỉ có nói 4 từ: “dog”, “cat”, “fish” và “bird”.

Một lần Bob đi du lịch xa, Bob liên lạc với Alice qua tin nhắn và mã hoá tin nhắn chỉ gồm các ký tự nhị phân $0$ và $1$ . Tin nhắn của Bob như sau:

Để thuận tiện cho việc trao đổi, Bob và Alice cùng thống nhất với nhau về cách thức mã hoá tin nhắn bằng cách thay thế từng từ thành chuỗi nhị phân (codeword) độ dài 2 bit tương ứng và ghép lại thành 1 chuỗi tin nhắn duy nhất. Cụ thể:

và giải mã thông tin như sau:

Mọi chuyện sẽ không đáng lo nếu như giá cước là $100$ đồng/1 bit, nhưng nay đã tăng lên là $500$ đồng/1 bit. Giá cả đắt đỏ chẳng nhẽ lại thôi không liên lạc nữa. Do vậy, Bob và Alice quyết tìm ra cách nào đó để tin nhắn ngắn hơn (để giảm cước phí) nhưng vẫn đảm bảo chuyển tải được đầy đủ thông tin.

Cùng nhau xem xét lại lịch sử các tin nhắn, Alice thấy rằng Bob tần suất các từ trong tin nhắn của Bob không tương đương với nhau. Cụ thể là: Bob thực sự thích “dog”, anh ấy chủ yếu nói về “dog” trong mọi tin nhắn của mình, thỉnh thoảng Bob mới nhắc đến 3 con vật còn lại là “cat”, “fish” và “bird”. Tần suất cụ thể như bảng thống kê dưới đây:

Phân tích một cách chi tiết hơn về codeword mà 2 bạn đã dùng bằng biểu đồ dưới đây, với: Trục tung - Thể hiện xác suất xuất hiện $p(x)$ của 1 word; Trục hoành - Độ dài $L(x)$ của codeword tương ứng; Diện tích - Expected codeword lenght: Độ dài kỳ vọng hay độ dài trung bình của một codeword được gửi đi, ở đây = 2 bit:

Như vậy, mục tiêu của 2 bạn là cực tiểu độ dài của tin nhắn gửi đi. Ở đây là hoàn toàn có thể lựa chọn codeword có độ dài khác nhau. Theo thuật toán tham lam thì word nào xuất hiện nhiều (word phổ biến, ví dụ như “dog”) sẽ ưu tiên chọn độ dài codeword tương ứng ngắn hơn và ngược lại những word nào xuất hiện ít (word hiếm, ví dụ như “bird”) thì codeword sử dụng sẽ dài hơn. Cụ thể ta có được như sau:

Biểu đồ phân tích cho bộ codeword mới như sau:

Để ý rằng trong biểu đồ trên độ dài của codeword phổ biến ngắn hơn trong khi đó độ dài của codeword hiếm là dài hơn. Phần diện tích được tính toán cũng nhỏ hơn,và tương ứng với độ dài trung bình của codeword là $1.75$ . Như vậy bằng cách sử dụng codeword có độ dài khác nhau ta có thể làm cho độ dài trung bình của codeword nhỏ hơn.

Bạn cũng có thể tự hỏi rằng tại sao ko dùng tất cả codeword độ dài bằng 1 cả. Với cách này thì bạn sẽ gặp phải vấn đề nhập nhằng (ambiguity) trong quá trình giải mã (decode)(sẽ giải thích cụ thể hơn ở phần tiếp).

Với ví dụ trên cùng với phân bố xác suất $p(x) = (\frac{1}{2}, \frac{1}{4}, \frac{1}{8}, \frac{1}{8})$ , thì $1.75$ là giá trị tối ưu, nghĩa là chúng ta sẽ không tìm được bộ codeword nào phù hợp mà có giá trị trung bình nhỏ hơn $1.75$ .

Như vậy, các bạn có thể thấy rằng với mỗi bộ phân bố xác suất $p(X)$ cho trước, ta hoàn toàn xác định được giá trị tối ưu của code, hay độ dài trung bình tối ưu của codeword. Và giá trị này được gọi là Entropy.

Không gian codeword

Chúng ta có 2 codeword độ dài 1 là: 0 và 1; 4 codeword độ dài 2 là: 00, 01, 10, 11; và tổng quát là $2^n$ codeword độ dài n.

Như trên đã nói, bạn hoàn toàn có thể tuỳ ý lựa chọn codeword có độ dài bất kỳ. Ví dụ như hình trên là 8 codeword độ dài 3, bạn có thể lựa chọn một cách tổ hợp các codeword có độ dài khác nhau như bạn chọn 2 codeword độ dài 2, 4 codeword độ dài 3 chẳng hạn.

Vậy điều gì quyết định đến việc chọn lựa codeword với độ dài khác nhau.

Ở hình dưới, Bob mã hoá tin nhắn bằng cách thay thế từng word bằng codeword tương ứng và ghép lại thành một chuỗi mã hoá nhị phân.

Có một điều bạn cần lưu ý ở đây là làm thế nào để từ chuỗi mã hoá bạn có thể giải mã ngược lại thành chuỗi các codeword. Nếu như chọn codeword có độ dài như nhau thì việc này khá đơn giản. Tuy nhiên bạn lựa chọn codeword độ dài khác nhau việc giải mã ngược lại được thành chuỗi codeword là việc hết sức quan trọng.

Thực tế, bạn cần chọn bộ codeword sao cho việc giải mã là duy nhất. Bằng không bạn sẽ rơi vào tình trạng “nhập nhằng”, nghĩa là từ một chuỗi mã hoá sẽ có nhiều chuỗi giải mã thoả mãn. Ví dụ, nếu bạn chọn cả $0$ và $01$ trong bộ codeword của bạn, thì với chuỗi mã hoá $01101$ bạn sẽ khó quyết định đâu là codeword phù hợp được dùng để giải mã cho 2 bit đầu. Do đó, bạn sẽ không chọn bộ codeword là prefix code - nghĩa là không codeword nào là prefix của codeword trong cùng một bộ.

Để dễ dàng cho việc lựa chọn prefix code, bạn sẽ sử dụng một phương pháp gọi là “hi sinh”, nghĩa là khi bạn đã chọn một codeword, ví dụ như $01$ , thì toàn bộ không gian codeword bắt đầu bằng $01$ sẽ không được sử dụng, ví dụ bạn sẽ không được dùng các codeword như: $010$ , $0101$ , … bởi nó sẽ gây ra tình trạng “nhập nhằng” cho quá trình giải mã.

Với $\frac{1}{4}$ trong tổng số codeword bắt đầu bằng $01$ , như vậy nếu codeword $01$ được chọn, bạn sẽ phải “hi sinh” $\frac{1}{4}$ tổng số codeword. Đây là “chi phí” bạn phải trả để có được một codeword độ dài 2.

Optimal Encoding - Mã tối ưu

Ở đây, bạn coi việc này giống như bạn đang có một ngân khố đầy đủ với tỷ lệ $\frac{1}{1}$ , mỗi khi bạn chọn một codeword độ dài L thì theo thuyết “hi sinh” ở trên bạn phải “hi sinh” một “chi phí” với tỷ lệ codeword là $\frac{1}{2^L}$ .

Chi phí cho codeword có độ dài $0$ là $1$ - tức toàn bộ codeword - nghĩa là nếu bạn chọn codeword có độ dài 0 thì bạn sẽ không được chọn bất kỳ codeword nào khác nữa; Chi phí cho codeword độ dài 1, ví dụ như codeword $0$ , là $\frac{1}{2}$ vì có $\frac{1}{2}$ số lượng codeword bắt đầu bằng $0$ ; Chi phí cho codeword độ dài 2, ví dụ “ $10$ ”, là $\frac{1}{4}$ vì có $\frac{1}{4}$ số lượng codewprd bắt đầu bằng “10”. Tổng quát, Chi phí cho codeword giảm theo hàm luỹ mũ của độ dài codeword.

Công thức tính Entropy

Chi phí cho codeword độ dài L là $cost = \frac{1}{2^L}$ , hay ngược lại nếu ta biết $cost$ của 1 codeword thì ta có thể tính được độ dài của codeword như sau: $l = \log_{2}(\frac{1}{cost})$ . Nếu bạn “tiêu” một chi phí $p(x)$ cho codeword $x$ , độ dài của codeword x sẽ là $\log_{2}(\frac{1}{p(x)})$ .

Với một phân bố xác suất cụ thể $p$ , ta xác định được độ dài trung bình ngắn nhất của bộ codeword - được gọi là “entropy” của $p$ , kí hiệu là $H(p)$ . Ta có:

$\begin{equation} H(p) = \sum_{x} p(x) \log_{2}(\frac{1}{p(x)}) = -\sum_{x} p(x) \log_{2}(p(x)) \end{equation}$

Nói một cách khác, nếu x là một sự kiện ngẫu nhiên rời rạc (có thể nhận các giá trị là 1..n), $p(x)$ là xác suất xảy ra của giá trị x, thì Entropy chính là giá trị kỳ vọng số bits được mã hoá tối ưu. Như vậy, trung bình mỗi khi cần nhắn tin, Bob và Alice cần sử dụng ít nhất $H(p)$ bit.

Entropy mô tả độ “không chắc chắn” của thông tin và là một cách để bạn định lượng được thông tin này. Giả sử nếu bạn biết chắc chắn có 2 sự kiện xảy ra với xác suất 50/50, bạn chắc chắn chỉ cần dùng 1 bit để nhắn tin. Hoặc nếu bạn biết có 16 sự kiện xảy ra với xác suất như nhau và $= \frac{1}{16}$ thì bạn chắc chắn chỉ cần 4 bit để nhắn tin.

Cross Entropy

Trở lại với câu chuyện của Bob và Alice, lúc trước 2 bạn chỉ nói tới sự quan tâm của Bob về 4 loại động vật: $dog$ , $cat$ , $fish$ và $bird$ , đặc biệt sở thích của Bob về $dog$ . Có chút thay đổi trong hoàn cảnh này là với Alice, cô cũng thích cả 4 loại động vật trên như Bob, nhưng cô thích nói về $cat$ hơn cả. Như vậy, 2 người có cùng “ $vocabulary size$ ” nhưng khác nhau về tần suất cho từng loại. Bob có thể nói cả ngày về chủ đề $dog$ , trong khi đó Alice lại cũng có thể nói cả ngày với chủ đề $cat$ .

Cụ thể như hình dưới đây:

Ban đầu, Alice gửi tin cho Bob cùng sử dụng bộ code của Bob. Tuy nhiên tin nhắn của Alice lại có vẻ dài hơn so với mong đợi của 2 bạn. Bộ code của Bob đã được tối ưu dựa trên phân bố xác suất của Bob. Alice đã sử dụng bộ code được tối ưu (suboptimal) dựa trên phân bố xác suất của riêng mình. Do đó trong khi độ dài trung bình codeword của Bob là sử dụng bộ code của Bob là $1.75$ bit, thì độ dài trung bình codeword của Alice sử dụng bộ code của Bob lại dài hơn là $2.25$ bit.

Vậy làm sao để đánh giá 2 codeword này??

Cross-Entropy là độ đo đánh giá độ dài trung bình số lượng bit cần thiết để mã hoá thông điệp với phân bố xác suất là $q(x)$ , sử dụng bộ codeword tối ưu (có phân bố xác suất là $p(x)$ ).

Nếu bạn nghĩ phân bố xác suất là một tool để mã hoá thông tin, thì entropy là độ đo để đánh giá số lượng bit bạn cần để sử dụng tool chuẩn $p(x)$ - đây là tool đã được tối ưu vì bạn không thể mã hoá sử dụng số bit trung bình ít hơn.

Ngược lại, cross-entropy là số lượng bit bạn cần để nếu bạn mã hoá thông tin của tool chuẩn $p(x)$ sử dụng tool sai $q(x)$ . Nghĩa là khi mã hoá thông điệp cho sự kiện $i^{th}$ thay vì sử dụng $\log_{2} \frac{1}{p(x_{i})}$ bit bạn lại dùng $log_{2} \frac{1}{q(x_{i})}$ bit.

Ta có: $H(p, q) = H_{q}(p) = \sum_{x} p(x) \log(\frac{1}{q(x)}) = - \sum_{x} p(x) \log(q(x))$

Ví dụ ta có:

Cross-entroy luôn luôn lớn hơn Entropy; Việc mã hoá sử dụng tool sai $q(x)$ sẽ luôn phải sử dụng nhiều bit hơn.
Cross-entropy không có tính chất đối xứng, nghĩa là $H(p, q) \neq H(q, p)$ .

Ta có thể có một vài kịch bản sau:

Bob sử dụng Bob code: $H(p) = H_{p}(p) = 1.75$ bit
Alice sử dụng Bob code: $H_{p}(q) = 2.25$ bit
Alice sử dụng Alice code: $H(p) = H_{q}(q) = 1.75$ bit
Bod sử dụng Alice code: $H_{q}(p) = 2.375$ bit

Tại sao cross-entropy lại quan trọng ???

Cross-entropy cho biết sự mức độ khác biệt giữa 2 phân bố xác suất. Sự khác biệt giữa phân bố $p$ và $q$ càng lớn, thì cross-entropy của p đối với q sẽ càng lớn hơn entropy của p.

Tương tự, sự khác biệt giữa phân bố $p$ và $q$ càng lớn, thì cross-entropy của q đối với p sẽ càng lớn hơn entropy của q.

KL Divergence - KL phân kỳ

Điều thực sự thú vị ở đây chính là sự khác biệt giữa entropy và cross-entropy. Có thể nói nó là sự khác biệt hay khoảng cách giữa 2 phân bố xác suất $p(x)$ và $q(x)$ . Nếu 2 phân bố xác suất này giống nhau thì khoảng cách là $0$ và ngược lại sự khác biệt càng lớn thì giá trị này càng lớn.

Và nó được gọi là KL divergence:

\begin{equation} D( p | q) = \sum_x p_x \log \frac{1}{q_x} - \sum_x p_x \log \frac{1}{p_x} = \sum_x p_x \log \frac{p_x}{q_x} = H(P, Q) - H(P) \end{equation}

với $H(P, Q)$ là cross-entropy; $H(P)$ là entropy của P.

Lưu ý:

Việc cực tiểu hoá cross entroypy tương đương với việc cực tiểu hoá KL phân kỳ.
Cross entropy và KL phân kỳ được sử dụng phổ biến trong Machine Learning. Chúng ta thường muốn một phân bố xác suất nào đó tiến gần với một phân bố khác. Ví dụ như chúng ta muốn phân bố của dự đoán tiến gần với phân bố cơ sở. KL phân kỳ cho ta một cái nhìn tự nhiên về vấn đề trên, tuy nhiên có vẻ như cross entropy lại được biết đến và sử dụng rộng rãi hơn.

Khả năng dự đoán

Ở đây chúng ta sử dụng cross-entropy để đánh giá sự khác biệt giữa 2 phân bố xác suất $y$ và $\hat{y}$ và tính lỗi (loss) dựa trên tổng cross entropy của toàn bộ dữ liệu training.

Cụ thể ta có hàm mục tiêu như sau:

\begin{equation} H({y^{(n)}}, {\hat{y}^{(n)}}) = \sum_n H(y^{(n)}, \hat{y}^{(n)}) \end{equation}

Một cách tiếp cận phổ biến khác là chúng ta tiến hành điều chỉnh tham số mô hình sao cho likelihood của mô hình với dữ liệu đầu vào đạt max. Với bài toán phân lớp chúng ta thường hay sử dụng mô hình phân biệt (discriminative model) ở đó dữ liệu training thường bao gồm cả dữ liệu và nhãn cần dự đoán. Nói cách khác chúng ta thường sẽ dự đoán ground-truth labels với dữ liệu cho trước.

Với giả sử dữ liệu của bài toán là độc lập và phân bố đồng nhất (independent and identically distributed), likelihood sẽ được tính như sau:

$L(\{y^{(n)}\}, \{\hat{y}^{(n)}\}) = \prod_n L(y^{(n)}, \hat{y}^{(n)})$

Vậy thế nào là likelihood? Đó chính là phần tử cụ thể của $\hat{y}^{(n)}$ tương ứng với ground-truth label của $y^{(n)}$ .

Ví dụ trong bài toán phân loại ảnh số MNIST: Với ảnh training thứ nhất có nhãn là $y^{(1)} = (0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)^T$ , thì likelihood $L(y^{(1)}, \hat{y}^{(1)})$ sẽ là phần tử thứ 3-th của kết quả dự đoán $\hat{y}^{(1)} = (0.0, 0.1, 0.1, 0.25, 0.0, 0.1, 0.1, 0.35, 0.0, 0.0)^T$ , hay $L(y^{(1)}, \hat{y}^{(1)}) = \hat{y}_{1}^{(1)} = 0.25$ .

Tiếp tục giả sử chúng ta có tất cả 3 ảnh trong training data là các số 3, 5, 8 với các phân bố ground-truth là:

$y^{(1)} = (0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)^T$ ,

$y^{(2)} = (0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0)^T$ , và

$y^{(3)} = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)^T$ .

Mô hình sẽ dự đoán 3 phân bố tương ứng là:

$\hat{y}^{(1)} = (0.0, 0.1, 0.1, 0.25, 0.0, 0.1, 0.1, 0.35, 0.0, 0.0)^T$ ,

$\hat{y}^{(2)} = (0.0, 0.1, 0.1, 0.25, 0.0, 0.3, 0.1, 0.15, 0.0, 0.0)^T$ , và

$\hat{y}^{(3)} = (0.0, 0.1, 0.1, 0.25, 0.0, 0.1, 0.1, 0.0, 0.35, 0.0)^T$ .

Và likelihood của cả training data sẽ là:

$L(\{y^{(1)}, y^{(2)}, y^{(3)}\}, \{\hat{y}^{(1)}, \hat{y}^{(2)}, \hat{y}^{(3)}\}) = \hat{y}^{(1)}_3 \, \hat{y}^{(2)}_5 \, \hat{y}^{(3)}_8 \$

Vậy nhiệm vụ của chúng ta là điều chỉnh tham số mô hình sao cho likelihood $L(\{y^{(n)}\}, \{\hat{y}^{(n)}\})$ đạt max.

Likelihood

Cùng phân tích cụ thể hơn về công thức tính likelihood trên:

Thứ nhất, hàm logarit là hàm đơn điệu, do vậy việc cực đại hoá likelihood sẽ tương đương với việc cực đại hoá log likelihood, hay ngược lại là tương đương với việc cực tiểu hoá negative log likelihood.

$-\log L(\{y^{(n)}\}, \{\hat{y}^{(n)}\}) = -\log \prod_n L(y^{(n)}, \hat{y}^{(n)}) = -\sum_n \log L(y^{(n)}, \hat{y}^{(n)})$

Thứ hai, như chúng ta phân tích ở phần trên, log likelihood của $y^{(n)}$ được tính khá đơn giản chính là log của phần tử tương ứng trong $\hat{y}^{(n)}$ , cụ thể hơn là phần tử thứ $i$ thoả mãn $y^{(n)}_i = 1.0$ .

Do đó chúng ta có thể viết lại công thức tính log likelihood cho mẫu training data thứ $n$ đơn giản hơn như sau:

$\log L(y^{(n)}, \hat{y}^{(n)}) = \sum_i y^{(n)}_i \log \hat{y}^{(n)}_i$

và negative log likelihood cũng được viết lại như sau:

$- \log L(\{y^{(n)}\}, \{\hat{y}^{(n)}\}) = -\sum_n \sum_i y^{(n)}_i \log \hat{y}^{(n)}_i$

Và đây chính là công thức tính tổng tất cả cross-entropy trên toàn bộ training data:

$-\log L(\{y^{(n)}\}, \{\hat{y}^{(n)}\}) = \sum_n \big[-\sum_i y_i \log \hat{y}^{(n)}_i\big] = \sum_n H(y^{(n)}, \hat{y}^{(n)})$

Thảo luận

Khi xây dựng mô hình xác suất cho bài toán phân lớp có các lớp phân biệt lẫn nhau, chúng ta cần đánh giá sự khác biệt giữa xác suất dự đoán $\hat{y}$ và xác suất ground-truth $y$ và trong quá trình training chúng ta sẽ điều chỉnh tham số sao cho sự khác biệt là nhỏ nhất.

Và các bạn có thể nhận thấy rằng, cross-entropy là một lựa chọn phù hợp cho bài toán phân lớp trên.

Có 2 khía cạnh đánh giá việc tiếp cận này:

Thứ nhất, việc cực tiểu hoá cross-entropy cho phép chúng ta tìm được $\hat{y}$ thoả mãn đáp ứng số bits tối thiểu cần thiết để mã hoá thông tin từ $y$ sử dụng $\hat{y}$
Thứ hai, việc cực tiểu hoá cross-entropy tương đương với việc cực tiểu hoá negative log likelihood hay chính là việc đánh giá trực tiếp khả năng dự đoán của mô hình.

Nguồn tham khảo

Visual Information Theory