Hướng dẫn dùng plotting car python

PyTorch là một framework được xây dựng dựa trên python cung cấp nền tảng tính toán khoa học phục vụ lĩnh vực Deep learning. Pytorch tập trung vào 2 khả năng chính:

• Một sự thay thế cho bộ thư viện numpy để tận dụng sức mạnh tính toán của GPU.
• Một platform Deep learning phục vụ trong nghiên cứu, mang lại sự linh hoạt và tốc độ.

Ưu điểm:

• Mang lại khả năng debug dễ dàng hơn theo hướng interactively, rất nhiều nhà nghiên cứu và engineer đã dùng cả pytorch và tensorflow đều đánh giá cáo pytorch hơn trong vấn đề debug và visualize.
• Hỗ trợ tốt dynamic graphs.
• Được phát triển bởi đội ngũ Facebook.
• Kết hợp cả các API cấp cao và cấp thấp.

Nhược điểm:

• Vẫn chưa được hoàn thiện trong việc deploy, áp dụng cho các hệ thống lớn,... được như framework ra đời trước nó như tensorflow.
• Ngoài document chính từ pytorch thì vẫn còn khá hạn chế các nguồn tài liệu bên ngoài như các tutorials hay các câu hỏi trên stackoverflow.

Ma trận

• Trong pytorch, ma trận[mảng] được gọi là các tensors.
• Ma trận 2 chiều 3 * 3 được gọi là 3 * 3 tensor.
• Cùng nhìn lại ví dụ về mảng[array] với numpy mà chúng ta đều đã biết:

1. Ta tạo numpy array với hàm np.array[]
2. Type[]: type của array. Trong ví dụ này đó là kiểu numpy.
3. np.shape[]: kính cỡ của array. Hàng x Cột

# import numpy library
import numpy as np

# numpy array
array = [[1,2,3],[4,5,6]]
first_array = np.array[array] # 2x3 array
print["Array Type: {}".format[type[first_array]]] # type
print["Array Shape: {}".format[np.shape[first_array]]] # shape
print[first_array]

output:

Array Type: 
Array Shape: [2, 3]
[[1 2 3]
 [4 5 6]]

Chúng ta đã hiểu qua về numpy array giờ hãy cùng xem cách implement tensor array[pytorch array].

• Thêm thư viện pytorch bằng dòng code: import torch
• Chúng ta tạo tensor với hàm torch.Tensor[].
• type: Kiểu array. Trong ví dụ này là tensor.
• shape: kích cỡ của array. Hàng x Cột

# import pytorch library
import torch

# pytorch array
tensor = torch.Tensor[array]
print["Array Type: {}".format[tensor.type]] # type
print["Array Shape: {}".format[tensor.shape]] # shape
print[tensor]

output:

Array Type: 
Array Shape: torch.Size[[2, 3]]

 1  2  3
 4  5  6
[torch.FloatTensor of size 2x3]

Phân phối là một trong những kĩ thuật được sử dụng nhiều nhất trong coding. Hãy cùng xem cách làm nó trong pytorch.

Hãy cùng so sánh numpy và tensor:

• np.ones[] = torch.ones[]
• np.random.rand[] = torch.rand[]

# numpy ones
print["Numpy {}\n".format[np.ones[[2,3]]]]

# pytorch ones
print[torch.ones[[2,3]]]

output:

Numpy [[1. 1. 1.]
 [1. 1. 1.]]


 1  1  1
 1  1  1
[torch.FloatTensor of size 2x3]

Với tensor:

# numpy random
print["Numpy {}\n".format[np.random.rand[2,3]]]

# pytorch random
print[torch.rand[2,3]]

output:

Numpy [[0.18841978 0.61702582 0.95432382]
 [0.16407638 0.18776019 0.52468443]]


 0.3779  0.3206  0.8350
 0.4805  0.5554  0.2068
[torch.FloatTensor of size 2x3]

Kể cả khi tôi sử dụng pytorch cho neural networks, tôi vẫn cảm thấy tốt hơn khi sử dụng numpy. Vì thế mà tôi thường xuyên convert kết quả của neural network từ tensor sang numpy array để visualize hoặc đánh giá.

Hãy cùng xem cách chuyển qua lại giữa tensor và numpy array:

• torch.from_numpy[]: từ numpy sang tensor
• numpy[]: từ tensor sang numpy

# random numpy array
array = np.random.rand[2,2]
print["{} {}\n".format[type[array],array]]

# from numpy to tensor
from_numpy_to_tensor = torch.from_numpy[array]
print["{}\n".format[from_numpy_to_tensor]]

# from tensor to numpy
tensor = from_numpy_to_tensor
from_tensor_to_numpy = tensor.numpy[]
print["{} {}\n".format[type[from_tensor_to_numpy],from_tensor_to_numpy]]

output:

 [[0.93007643 0.87933967]
 [0.99716134 0.69613825]]


 0.9301  0.8793
 0.9972  0.6961
[torch.DoubleTensor of size 2x2]


 [[0.93007643 0.87933967]
 [0.99716134 0.69613825]]

Toán học cơ bản với pytorch

• Resize: view[]
• a và b là tensor.
• Phép cộng: torch.add[a,b] = a + b
• Phép trừ: a.sub[b] = a - b
• Phép nhân tương ứng từng phần tử: torch.mul[a,b] = a * b
• Phép chia tương ứng từng phần tử: torch.div[a,b] = a / b
• Mean: a.mean[]
• Độ lệch tiêu chuẩn [std]: a.std[]

Array Type: 
Array Shape: [2, 3]
[[1 2 3]
 [4 5 6]]

output:

Array Type: 
Array Shape: [2, 3]
[[1 2 3]
 [4 5 6]]

Variables

Nếu các bạn chưa có kiến thức về backpropagation hay gradient thì các bạn nên đọc bài viết về neural network của mình tại đây để có thể hiểu được các phần tiếp theo.

Variable là class bao bọc [wrapper] Tensor cho phép thực hiện tính toán đạo hàm. Variable lưu trữ data [tensor] và grad [gradient].

Array Type: 
Array Shape: [2, 3]
[[1 2 3]
 [4 5 6]]

output:

Array Type: 
Array Shape: [2, 3]
[[1 2 3]
 [4 5 6]]

• Giả sử ta có phương trình y = x^2
• Định nghĩa variable x = [2,4]
• Sau khi tính toán ta được y = [4,16] [y = x^2]
• Phương trình o: o = [1/2]sum[y] = [1/2]sum[x^2]
• Đạo hàm của o = x
• Kết qủa bằng x nên gradients là [2,4]

Array Type: 
Array Shape: [2, 3]
[[1 2 3]
 [4 5 6]]

output:

Array Type: 
Array Shape: [2, 3]
[[1 2 3]
 [4 5 6]]

Autograd

Minh họa cách tính Gradient tự động trong Pytorch bằng ví dụ sau: Cho đồ thị tính toán như hình. Đầu vào [x,y,z] = [5,3,7]. Tất cả các trọng số w đều được khởi tạo là 0.5. Tính kết quả [biến result] khi ta cho [x,y,z] qua mạng [forward] và gradient của mỗi trọng số w [backward].

Array Type: 
Array Shape: [2, 3]
[[1 2 3]
 [4 5 6]]

Giải thích :

Forward:

o1 = x * w1 * y * w2 = 5 * 0.5 * 3 * 0.5 = 3.75

o2 = o1 * w4 + z * w3 = 3.75 * 0.5 + 7 * 0.5 = 5.375

result = o2 * w5 = 5.375 * 0.5 = 2.6875

Backward:

Cần chú ý công thức đạo hàm của hàm hợp:

f'[u[x]] = f'[u] * u'[x]

result = o2 * w5

Đạo hàm của result theo w5 = [o2 * w5]' = o2 = 5.375

Đạo hàm của result theo o2 = f'[o2] = w5 = 0.5

o2 = o1 * w4 + z * w3

Đạo hàm của result theo w3 = f'[o2] * o2'[w3] = 0.5 * z = 3.5

Đạo hàm của result theo w4 = f'[o2] * o2'[w4] = 0.5 * o1 = 1.875

Đạo hàm của result theo o1 = g'[o1] = f'[o2] * o2'[o1] = 0.5 * w4 = 0.25

o1 = x * w1 * y * w2

Đạo hàm của result theo w1 = g'[o1] * o1'[w1] = 0.25 * x * y * w2 = 1.875

Đạo hàm của result theo w2 = g'[o1] * o1'[w2] = 0.25 * x * w1 * y = 1.875

Linear Regression

Nếu các bạn chưa có kiến thức về Linear Regression thì có thể tham khảo tại đây.

• Hàm y = Ax + B.
• Ví dụ: giả sử chúng ta có một công ty ô tô. Nếu giá xe xuống thấp, chúng ta sẽ bán được nhiều xe hơn. Nếu giá xe tăng cao, ta bán được ít xe hơn. Đây là thực tế mà chúng ta biết và chúng ta có dữ liệu về điều này.
• Câu hỏi đặt ra là làm sao để ước lượng được số xe ta sẽ bán được khi mà giá xe là 100.

Array Type: 
Array Shape: [2, 3]
[[1 2 3]
 [4 5 6]]

Hình trên ta đã plot dữ liệu mà ta thu thập được và câu hỏi đặt ra là tìm số lượng xe sẽ bán được khi giá ô tô là 100. Để trả lời câu hỏi này ta sẽ cần sử dụng Linear Regression. Về cơ bản chúng ta sẽ cố tạo ra một đường thẳng fit với dữ liệu đã được plot ở trên và cố gắng tinh chỉnh đường thẳng đó sao cho giảm được độ lệch vs data.

Các bước thực hiện Linear Regression

• Tạo lớp LinearRegression
• Tạo model trong class LinearRegression
• MSE: Mean squared error
• Optimization [SGD:stochastic gradient descent]
• Backpropagation
• Đưa ra dự đoán

Array Type: 
Array Shape: [2, 3]
[[1 2 3]
 [4 5 6]]

output:

Array Type: 
Array Shape: [2, 3]
[[1 2 3]
 [4 5 6]]

• Số vòng lặp là 1001.
• Bạn có thể thấy từ epoch 1000 loss đã gần như bằng 0
• Như vậy bây giờ ta đã có một model đã được huấn luyện
• Và giờ thì dùng model đó để dự đoán cho bài toán của chúng ta thôi

# import pytorch library
import torch

# pytorch array
tensor = torch.Tensor[array]
print["Array Type: {}".format[tensor.type]] # type
print["Array Shape: {}".format[tensor.shape]] # shape
print[tensor]

Mình hy vọng với phần 1 này các bạn đã làm quen được với pytorch và có thể tự mình code thành thục được một số chức năng cơ bản. Ở phần 2 chúng ta sẽ đi vào tìm hiểu cách implement pytorch cho một số mô hình deep learning.