Numpy
Phần tiếp theo trong khóa học lập trình python này sẽ trình bày về thư viện toán học numpy. Đây là một thư viện hỗ trợ đắc lực cho tính toán ma trận. Để biết cụ thể numpy là cái gì chúng ta hãy cũng nhau tìm hiểu nhé.
Numpy là một thư viện lõi phục vụ cho khoa học máy tính của Python. Nó hỗ trợ mạnh mẽ cho các array nhiều chiều, và các phương thức để làm việc với các mảng nhiều chiều này. Nếu bạn đã có kinh nghiệm sử dụng MATLAB, có thể tutorial này sẽ hữu ích để bạn bắt đầu với Numpy.
Arrays
Một numpy array là một mạng lưới các giá trị, và tất cả các giá trị phải có cùng kiểu dữ liệu. Chỉ số của numpy array được biểu diễn bằng các số nguyên không âm. Số chiều thì(1-D array -> vector, 2-D array – ma trận, …) được gọi là
rank của numpy array. Và shape của array là một tuple các số nguyên thể hiện cho kích thước của array theo mỗi chiều của aray.
Chúng ta có thể khởi tạo numpy array từ một container list trong python. Numpy array vẫn dùng cặp ngoặc vuông để truy cập tới từng phần tử.
import numpy as np
a = np.array([1, 2, 3]) # Tạo 1 numpy array rank = 1
print(type(a)) # Prints "<class 'numpy.ndarray'>"
print(a.shape) # Prints "(3,)"
print(a[0], a[1], a[2]) # Prints "1 2 3"
a[0] = 5 # Thay đổi giá trị của 1 phần tử
print(a) # Prints "[5, 2, 3]"
b = np.array([[1,2,3],[4,5,6]]) # Tạo 1 numpy array rank = 2
print(b.shape) # Prints "(2, 3)"
print(b[0, 0], b[0, 1], b[1, 0]) # Prints "1 2 4"
|
Numpy cũng có sẵn rất nhiều hàm hỗ trợ tạo numpy array:
import numpy as np
a = np.zeros((2,2)) # Tạo numpy array mà tất cả phần tử là 0
print(a) # Prints "[[ 0. 0.]
# [ 0. 0.]]"
b = np.ones((1,2)) # Tạo numpy array mà tất cả phần tử là 1
print(b) # Prints "[[ 1. 1.]]"
c = np.full((2,2), 7) # Tạo một mảng hằng
print(c) # Prints "[[ 7. 7.]
# [ 7. 7.]]"
d = np.eye(2) # Tạo ma trận đơn vị 2 x 2
print(d) # Prints "[[ 1. 0.]
# [ 0. 1.]]"
e = np.random.random((2,2)) # Tạo array với các giá trị ngẫu nhiên
print(e) # Might print "[[ 0.91940167 0.08143941]
# [ 0.68744134 0.87236687]]" |
Bạn có thể xem các phương pháp khởi tạo numpy array tại đây.
Truy xuất mảng(Array indexing)
Numpy cung cấp một số cách khác nhau để truy xuất vào các phần tử trong mảng(numpy array).
Trượt(Slicing): Tương tự như list trong Python, numpy array cũng có thể trượt trên mảng. Trong trường hợp mảng nhiều chiều, bạn phải chỉ định việc trượt trên tất cả các chiều của mảng:
import numpy as np
# Khởi tạo numpy array có shape = (3, 4) có giá trị như sau:
# [[ 1 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
# Sử dụng slicing để tạo numpy array b bằng cách lấy 2 hàng đầu tiên
# và cột 1, 2. Như vậy b sẽ có shape = (2, 2):
# [[2 3]
# [6 7]]
b = a[:2, 1:3]
# Một array tạo ra từ slicing sẽ có cùng địa chỉ với array gốc.
# Nếu thay đổi 1 trong 2 thì array còn lại cũng thay đổi.
print(a[0, 1]) # Prints "2"
b[0, 0] = 77 # b[0, 0] ở đây tương đương với a[0, 1]
print(a[0, 1]) # Prints "77"
Bạn cũng có thể kết hợp việc dùng slicing và dùng chỉ số. Tuy nhiên, cách làm đó sẽ cho ra một mảng mới có rank thấp hơn mảng gốc. Chú ý rằng nó sẽ khác việc slicing trong matlab:
import numpy as np
# Tạo một numpy array có shape (3, 4) với giá trị như sau:
# [[ 1 2 3 4]
# [ 5 6 7 8]
# [ 9 10 11 12]]
a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
# Dùng 2 cách khác nhau để tạo array mới từ array gốc
# Dùng kết hợp chỉ số và slice -> được array mới có rank thấp hơn,
# Nếu chỉ dùng slice ta sẽ có 1 array mới có cùng rank
# với array gốc
row_r1 = a[1, :] # Rank 1, hàng thứ 2 của a
row_r2 = a[1:2, :] # Rank 2, vẫn là hàng thứ 2 của a
print(row_r1, row_r1.shape) # Prints "[5 6 7 8] (4,)"
print(row_r2, row_r2.shape) # Prints "[[5 6 7 8]] (1, 4)"
# Chúng ta có thể làm tương tự với cột của numpy array:
col_r1 = a[:, 1]
col_r2 = a[:, 1:2]
print(col_r1, col_r1.shape) # Prints "[ 2 6 10] (3,)"
print(col_r2, col_r2.shape) # Prints "[[ 2]
# [ 6]
# [10]] (3, 1)"
Integer array indexing: Khi bạn truy xuất mảng sử dụng trượt, kết quả bạn thu được sẽ luôn là một mảng con của mảng ban đầu. Tuy nhiên, sử dụng chỉ số mảng cho phép bạn xây dựng các mảng tùy ý từ một mảng khác. Đây là một ví dụ:
import numpy as np
a = np.array([[1,2], [3, 4], [5, 6]])
# Truy xuất mảng dùng chỉ số.
# Kết quả thu được là 1 mảng có shape (3,)
print(a[[0, 1, 2], [0, 1, 0]]) # Prints "[1 4 5]"
# Sẽ thu được kết quả tương đương như trên với cách này:
print(np.array([a[0, 0], a[1, 1], a[2, 0]])) # Prints "[1 4 5]"
# Bạn được phép sử dụng chỉ số mảng để
# truy xuất tới 1 phần tử
# của mảng gốc nhiều hơn 1 lần
print(a[[0, 0], [1, 1]]) # Prints "[2 2]"
# Một cách làm khác tương đương:
print(np.array([a[0, 1], a[0, 1]])) # Prints "[2 2]" |
Có một mẹo khá là hay bạn có thể dùng chỉ số mảng để chọn hoặc thay đổi giá trị từng phần tử trong từng hàng của mảng:
import numpy as np
# Tạo 1 mảng numpy array
a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
print(a) # prints "array([[ 1, 2, 3],
# [ 4, 5, 6],
# [ 7, 8, 9],
# [10, 11, 12]])"
# Tạo một mảng lưu giữ chỉ số
b = np.array([0, 2, 0, 1])
# Lấy một phần tử từ mỗi hàng của a sử dụng các chỉ số đã lưu ở b
print(a[np.arange(4), b]) # Prints "[ 1 6 7 11]"
# Thay đổi một phần tử từ mỗi hàng của a sử dụng các chỉ số đã lưu ở b
a[np.arange(4), b] += 10
print(a) # prints "array([[11, 2, 3],
# [ 4, 5, 16],
# [17, 8, 9],
# [10, 21, 12]]) |
Boolean array indexing: Boolean array indexing cho phép bạn chọn ra các phần tử mà bạn mong muốn. Cách này thường sử dụng để chọn các phần tử thỏa mãn một điều kiện nào đó. Đây là một ví dụ:
import numpy as np
a = np.array([[1,2], [3, 4], [5, 6]])
bool_idx = (a > 2) # Tìm tất cả các phần tử có giá trị > 2;
# Trả về một boolean numpy array có cùng kích thước
# mà giá trị tại mỗi phần tử là True nếu phần tử
# của a tại đó > 2, và False cho TH ngược lại
print(bool_idx) # Prints "[[False False]
# [ True True]
# [ True True]]"
# Sử dụng một boolean array indexing để lấy
# các phần tử thỏa mãn điều kiện nhất định trong a
# Ví dụ ở đây in ra các giá trị của a > 2
# sử dụng array bool_idx đã tạo
print(a[bool_idx]) # Prints "[3 4 5 6]"
# Một cách viết ngắn gọn hơn cho cùng kết quả:
print(a[a > 2]) # Prints "[3 4 5 6]" |
Nếu bạn muốn tìm kiếm thêm thông tin về numpy array indexing thì hãy tham khảo bài viết này.
Kiểu dữ liệu
Tất cả các phần tử trong một numpy array phải có cùng kiểu dữ liệu. Numpy cung cấp một số lượng lớn các kiểu dữ liệu số mà bạn có thể sử dụng để xây dựng các mảng. Numpy sẽ cố gắng đoán kiểu dữ liệu khi bạn khởi tạo, nhưng các hàm khởi tạo numpy array cũng có một tham số tùy chọn để bạn chỉ định kiểu dữ liệu cụ thể mà bạn muốn. Ví dụ:
import numpy as np
x = np.array([1, 2]) # numpy tự xác định kiểu dữ liệu
print(x.dtype) # Prints "int64"
x = np.array([1.0, 2.0]) # numpy tự xác định kiểu dữ liệu
print(x.dtype) # Prints "float64"
x = np.array([1, 2], dtype=np.int64) # Chỉ định kiểu dữ liệu bởi người dùng
print(x.dtype) # Prints "int64"
|
Bạn có thể xem thêm chi tiết về các kiểu dữ liệu của numpy tại tài liệu này.
Phép toán trên numpy array
Các phép toán cơ bản trên numpy array được thực thi theo kiểu “từng phần tử của mảng này kết hợp với phần tử ở vị trí tương ứng của mảng kia” với các phép +, -, *, /. Xem ví dụ sau:
import numpy as np
x = np.array([[1,2],[3,4]], dtype=np.float64)
y = np.array([[5,6],[7,8]], dtype=np.float64)
# Cộng từng phần tử của x với từng phần tử của y với nhau. Cả 2 cách cho cùng một kết quả
# x[0][0] + y[0][0], x[0][1] + y[0][1], ...
# [[ 6.0 8.0]
# [10.0 12.0]]
print(x + y)
print(np.add(x, y))
# Tính hiệu từng phần tử của x với trừ cho từng phần tử của y. Cả 2 cách cho cùng một kết quả
# [[-4.0 -4.0]
# [-4.0 -4.0]]
print(x - y)
print(np.subtract(x, y))
# Tính tích từng phần tử của a nhân với từng phần tử của b.
# Cả 2 cách cho cùng 1 kết quả
# Lưu ý: Đây không phải là phép nhân hai ma trận trong toán học
# [[ 5.0 12.0]
# [21.0 32.0]]
print(x * y)
print(np.multiply(x, y))
# Thực hiện tính thương của từng phần tử trong x chia cho phần tử tương ứng trong y
# Cả 2 cách cho cùng 1 kết quả
# [[ 0.2 0.33333333]
# [ 0.42857143 0.5 ]]
print(x / y)
print(np.divide(x, y))
# Bình phương từng phần tử trong x
# [[ 1. 1.41421356]
# [ 1.73205081 2. ]]
print(np.sqrt(x))
Chú ý: Không giống như matlab, toán tử
* của numpy là phép nhân tích chập(từng phần tử nhân với nhau cho ra kết quả). Còn toán tử * trong matlab là phép nhân 2 ma trận. Để nhân 2 ma trận hoặc nhân vector với ma trận trong numpy, chúng ta sử dụng hàm dot:
# Ví dụ về dot function
import numpy as np
x = np.array([[1,2],[3,4]])
y = np.array([[5,6],[7,8]])
v = np.array([9,10])
w = np.array([11, 12])
# Tính tích trong của(inner product) 2 vector.
# Cả 2 đều in ra 219
print(v.dot(w))
print(np.dot(v, w))
# Nhân ma trận với vector. Cả 2 in ra array rank = 1: [29 67]
print(x.dot(v))
print(np.dot(x, v))
# Phép nhân trên 2 ma trận; Kết quả là một ma trận có rank = 2
# [[19 22]
# [43 50]]
print(x.dot(y))
print(np.dot(x, y))
Numpy cung cấp rất nhiều hàm hỗ trợ tính toán trên mảng. Một hàm ví dụ mà ta hay sử dụng là
sum:
# sum function
import numpy as np
x = np.array([[1,2],[3,4]])
print(np.sum(x)) # Tính tổng tất cả các phần tử; prints "10"
print(np.sum(x, axis=0)) # Tính tổng theo từng cột; prints "[4 6]"
print(np.sum(x, axis=1)) # Tính tổng theo từng hàng; prints "[3 7]"
Bạn có thể xem đầy đủ các hàm tính toán toán học của numpy tại đây.
Trong quá trình làm việc với mảng, chúng ta thường xuyên phải thay đổi kích thước của mảng. Ví dụ đơn giản nhất của trường hợp này là phép chuyển vị ma trận. Để lấy chuyển vị của một ma trận, chúng ta sử dụng thuộc tính
T của đối tượng mảng:
# Chuyển vị ma trận
import numpy as np
x = np.array([[1,2], [3,4]])
print(x) # Prints "[[1 2]
# [3 4]]"
print(x.T) # Prints "[[1 3]
# [2 4]]"
# Chuyển vị của vector là một vector không đổi:
v = np.array([1,2,3])
print(v) # Prints "[1 2 3]"
print(v.T) # Prints "[1 2 3]"
Numpy cung cấp rất nhiều hàm cho phép thao tác với mảng, bạn có thể xem danh sách đầy đủ tại đây.
Broadcasting
Broadcasting là một cơ chế mạnh mẽ cho phép bạn thực thi nhanh chóng với các phép toán số học trên các numpy array có kích thước khác nhau. Giả sử bạn có một mảng có kích thước nhỏ và mảng kia có kích thước lớn. Bạn muốn dùng mảng nhỏ kia nhiều lần để thay đổi giá trị của mảng lớn.
Ví dụ, chúng ta muốn cộng thêm một vector hằng vào từng hàng của một ma trận. Bạn có thể làm như sau:
import numpy as np
# Cộng thêm giá trị vector v vào từng hàng của x,
# chứa kết quả vào ma trận y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = np.empty_like(x) # Tạo một ma trận rỗng có kích thước như x
# Thêm vector v vào từng hàng của ma trận x sử dụng vòng lặp
for i in range(4):
y[i, :] = x[i, :] + v
# Và đây là y nhận được
# [[ 2 2 4]
# [ 5 5 7]
# [ 8 8 10]
# [11 11 13]]
print(y) |
Cách này hoạt động khá tốt, nhưng khi ma trận
x là rất lớn thì việc lặp này sẽ rất chậm. Nếu bạn để ý thì công việc này tương tự việc thực hiện cộng từng phần tử của x với một ma trận vv có kích thước như y và mỗi hàng là một vector v. Bạn có thể xem code để hiểu rõ hơn:
import numpy as np
# Cộng thêm giá trị vector v vào từng hàng của x,
# chứa kết quả vào ma trận y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
vv = np.tile(v, (4, 1)) # Copy thành xếp chồng chứa 4 vector v
print(vv) # Prints "[[1 0 1]
# [1 0 1]
# [1 0 1]
# [1 0 1]]"
y = x + vv # Thực hiện phép cộng
print(y) # Prints "[[ 2 2 4
# [ 5 5 7]
# [ 8 8 10]
# [11 11 13]]" |
Numpy broadcasting cho phép chúng ta thực thi tính toán này mà không cần phải tạo ra nhiều bản sao của
v. Và đây là code khi sử dụng broadcasting:
# Broadcasting
import numpy as np
# Cộng thêm giá trị vector v vào từng hàng của x,
# chứa kết quả vào ma trận y
x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
v = np.array([1, 0, 1])
y = x + v # Thêm v vào từng hàng của x sử dụng broadcasting
print(y) # Prints "[[ 2 2 4]
# [ 5 5 7]
# [ 8 8 10]
# [11 11 13]]"
Bằng cách dùng Broadcasting, dòng code
y = x + v vẫn làm việc thậm chí x có kích thước (4, 3) và v có kích thước (3,).Nguyên tắc
Broadcast thực thi trên 2 mảng theo quy tắc sau:
- Nếu các mảng không có cùng rank, tăng kích thước của mảng có rank thấp hơn cho tới khi cả 2 có cùng kích thước.
- Hai mảng được cho là tương thích trong một chiều nếu chúng có cùng kích thước trong chiều đó hoặc nếu một trong 2 mảng có kích là 1 trong chiều đó.
- Các mảng có thể thực hiện broadcast nếu chúng tương thích trên tất cả các chiều.
- Kết quả sau khi thực thi broadcast sẽ là một ma trận có kích thước bằng với kích thước của ma trận lớn hơn.
- Trong bất kỳ chiều nào mà mảng đầu có kích thước là 1 và mảng còn lại có kích thước lớn hơn 1, mảng đầu đó sẽ coi như là copy các giá trị của nó(ở chiều đó) theo chiều đó.
Nếu đoạn giải thích này chưa khiến bạn hiểu rõ ràng, hãy đọc giải thích ở tài liệu này hoặc bài giải thích này.
Các hàm thực thi broadcasting được gọi là universal functions. Bạn có thể tìm danh sách các hàm đó trong tài liệu này.
Một vài trường hợp sử dụng broadcasting khác:
import numpy as np
# Tính tích ngoài(outer product) của 2 vector
v = np.array([1,2,3]) # v has shape (3,)
w = np.array([4,5]) # w has shape (2,)
# Để tính tích ngoài(outer product), đầu tiên cần reshape v về shape (3, 1);
# Sau đó broadcast nó với w được 1 output có shape (3, 2),
# Đây là kết quả:
# [[ 4 5]
# [ 8 10]
# [12 15]]
print(np.reshape(v, (3, 1)) * w)
# Thêm một vector vào từng hàng của ma trận
x = np.array([[1,2,3], [4,5,6]])
# x có shape (2, 3) và v có shape (3,) vì vậy kết quả có shape (2, 3),
# có giá trị như sau:
# [[2 4 6]
# [5 7 9]]
print(x + v)
# Thêm một vector vào từng cột của ma trận
# x có shape (2, 3) và w có shape (2,).
# Nếu ta chuyển vị x thì shape x là (3, 2) và có thể broadcast
# với w cho ra kết quả có shape (3, 2); thực hiện chuyển vị kết quả này thu được
# ma trận shape (2, 3) là kết quả của x thêm v ở mỗi cột.
# Cho ta kết quả như sau:
# [[ 5 6 7]
# [ 9 10 11]]
print((x.T + w).T)
# Một cách khác là reshape w thành vector cột (2, 1);
# Sau đó ta có thể broadcast nó trực tiếp với x
# để cho ra cùng kết quả
print(x + np.reshape(w, (2, 1)))
# Nhân ma trận với hằng số:
# x có shape (2, 3). Numpy chỉ định hằng số có shape là ();
# Nó có thể broadcast với x có shape (2, 3), cho ra kết quả như sau:
# [[ 2 4 6]
# [ 8 10 12]]
print(x * 2)
|
Broadcasting giúp cho code của bạn trở nên ngắn gọn hơn và thực thi nhanh hơn. Vì vậy, bạn hãy cố gắng sử dụng nó khi có thể.
Tài liệu về Numpy
Những kiến thức trên đây của khóa học lập trình python đã cung cấp cho bạn rất nhiều hiểu biết cần thiết về numpy. Nhưng đó chưa phải tất cả, hãy đọc tài liệu này để có nhiều hơn kiến thức về numpy.
Phần tiếp theo trong khóa học lập trình python sẽ là bài hướng dẫn về thư viện Scipy. Hãy cùng Nguyễn Văn Hiếu tiếp tục tìm hiểu nhé.
SciPy
Numpy hỗ trợ rất mạnh mẽ cho mảng nhiều chiều và cung cấp các chức năng cơ bản cho việc tính toán vào các mảng nhiều chiều này. Scipy được xây dựng trên nền tảng của Numpy, cung cấp rất nhiều các hàm để hỗ trợ tính toán trên các numpy arrays. Scipy được sử dụng trong nhiều bài toán và lĩnh vực khác nhau.
Scipy trong xử lý ảnh (Image operations)
Scipy cung cấp một số hàm cơ bản để làm việc với ảnh. Ví dụ, nó có các hàm để đọc ảnh từ ổ cứng thành 1 numpy arrays, lưu numpy arrays thành file ảnh trong ổ cứng, thay đổi kích thước của ảnh. Đây là một ví dụ đơn giản chứng minh cho điều đó:
from scipy.misc import imread, imsave, imresize
# Đọc 1 ảnh JPEG vào 1 numpy arrays
img = imread('../assets/cat.jpg')
print(img.dtype, img.shape) # Prints "uint8 (400, 248, 3)"
# Chúng ta có thể thay đổi màu sắc của ảnh bằng cách
# thay đổi giá trị trên từng kênh màu(R,G, B)
# Ảnh có kích thước (400, 248, 3) - 3 là số kênh màu;
# Chúng ta nhân nó với array [1, 0.95, 0.9] có kích thước (3,);
# Điều này có nghĩa là giá trị kênh màu Red không đổi,
# nhân thêm ở kênh màu green và blue thêm 0.95 và 0.9
img_tinted = img * [1, 0.95, 0.9]
# Thay đổi kích thước ảnh img_tinted về 300 by 300 pixels.
img_tinted = imresize(img_tinted, (300, 300))
# Lưu ảnh img_tinted vào ổ cứng
imsave('../assets/cat_tinted.jpg', img_tinted) |
Bạn có thể xem sử thay đổi vì ảnh đã lưu trong thư mục assets. Bên trái là ảnh gốc và bên phải là ảnh đã thay đổi màu + thay đổi kích thước.
MATLAB files
Các hàm
scipy.io.loadmat vàscipy.io.savemat. Hai hàm này cho phép bạn đọc và ghi matlab files. Bạn có thể đọc về nó tại tài liệu này.Khoảng cách giữa các điểm
Scipy định nghĩa một số hàm hữu ích cho việc tính khoảng cách giữa các điểm.
Hàm
scipy.spatial.distance.pdist: tính toán khoảng cách giữa 2 cặp điểm bất kỳ trong một tập hợp các điểm được cho.
import numpy as np
from scipy.spatial.distance import pdist, squareform
# Tạo một numpy array mà mỗi hàng là một điểm trong không gian 2 chiều:
# [[0 1]
# [1 0]
# [2 0]]
x = np.array([[0, 1], [1, 0], [2, 0]])
print(x)
# tính khoảng cách Euclidean giữa tất cả các hàng trong x.
# d[i, j] là khoảng cách Euclidean giữa x[i, :] và x[j, :],
# Và d sẽ có giá trị như sau:
# [[ 0. 1.41421356 2.23606798]
# [ 1.41421356 0. 1. ]
# [ 2.23606798 1. 0. ]]
d = squareform(pdist(x, 'euclidean'))
print(d) |
Bạn có thể đọc đầy đủ thông tin chi tiết về hàm này trong tài liệu này.
Một hàm tương tự (
scipy.spatial.distance.cdist). Nó giúp tính toán khoảng cách giữa các cặp điểm trong 1 tập hợp các điểm cho trước; bạn có thể đọc thêm trong tài liệu này.