NumPy (Numerical Python) là thư viện cốt lõi trong Python, cung cấp một đối tượng mảng đa chiều hiệu suất cao và các công cụ để làm việc với chúng. Nó là nền tảng cho nhiều thư viện tính toán khoa học khác trong Python.

import numpy as np

1. Đọc dữ liệu từ file văn bản (.txt)

NumPy có thể đọc dữ liệu từ các tệp văn bản có cấu trúc bằng hàm np.genfromtxt(). Điều này rất hữu ích khi làm việc với các tập dữ liệu lớn.

# Đọc dữ liệu từ file 'du_lieu_khach_hang.txt'
# delimiter = "," : chỉ định dấu phân cách là dấu phẩy
# dtype = "U50" : chỉ định kiểu dữ liệu là chuỗi Unicode độ dài tối đa 50 ký tự
# skip_header = 1 : bỏ qua dòng đầu tiên (thường là tiêu đề)
thong_tin_khach_hang = np.genfromtxt("du_lieu_khach_hang.txt", delimiter = ",", dtype = "U50", skip_header = 1)
print(thong_tin_khach_hang)

2. Khởi tạo mảng NumPy (ndarray)

Đối tượng trung tâm của NumPy là ndarray (N-dimensional array), một container linh hoạt cho các tập dữ liệu lớn. Các phần tử trong một mảng NumPy phải có cùng kiểu dữ liệu.

# Khởi tạo một mảng một chiều (vector)
mang_mot_chieu = np.array([10, 20, 30, 40, 50])
print("Mảng một chiều:\n", mang_mot_chieu)

# Khởi tạo một mảng hai chiều (ma trận)
ma_tran_so_lieu = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("Ma trận hai chiều:\n", ma_tran_so_lieu)

3. Kiểm tra kiểu dữ liệu của mảng

Mỗi mảng NumPy có một thuộc tính dtype cho biết kiểu dữ liệu của các phần tử bên trong. Các kiểu phổ biến bao gồm bool, int32/64, float32/64 và str (hoặc U cho Unicode string).

print("Kiểu dữ liệu của mảng một chiều:", mang_mot_chieu.dtype)
print("Kiểu dữ liệu của ma trận hai chiều:", ma_tran_so_lieu.dtype)

4. Truy cập và cắt lát mảng

Truy cập các phần tử hoặc tập hợp các phần tử trong mảng tương tự như danh sách Python, nhưng với khả năng chỉ mục đa chiều mạnh mẽ hơn.

# Lấy phần tử ở hàng thứ 2 (chỉ số 1), cột thứ 3 (chỉ số 2) của ma_tran_so_lieu
print("Phần tử [1, 2]:", ma_tran_so_lieu[1, 2])

# Lấy các hàng từ 0 đến 1 và các cột từ 0 đến 2
print("Cắt lát ma trận (hàng 0-1, cột 0-2):\n", ma_tran_so_lieu[0:2, 0:3])

# Lấy tất cả các hàng và tất cả các cột
print("Toàn bộ ma trận:\n", ma_tran_so_lieu[:, :])

5. Lọc mảng bằng điều kiện Boolean

NumPy cho phép bạn lọc các phần tử dựa trên một điều kiện boolean, trả về một mảng boolean tương ứng với điều kiện.

# Kiểm tra các phần tử trong mang_mot_chieu có lớn hơn 30 không
print("Mảng một chiều > 30:", mang_mot_chieu > 30)

# Kiểm tra xem các phần tử ở cột đầu tiên của ma_tran_so_lieu có bằng 7 không
print("Cột 0 == 7:", ma_tran_so_lieu[:, 0] == 7)

6. Trích xuất phần tử dựa trên điều kiện

Sử dụng mảng boolean làm chỉ mục để trích xuất các phần tử thỏa mãn điều kiện.

# Trích xuất các phần tử của mang_mot_chieu lớn hơn 30
dieu_kien = (mang_mot_chieu > 30)
print("Các phần tử lớn hơn 30:", mang_mot_chieu[dieu_kien])

7. Trích xuất hàng dựa trên điều kiện

Tương tự, bạn có thể trích xuất toàn bộ hàng từ một ma trận nếu một điều kiện nào đó được thỏa mãn ở một cột cụ thể.

# Trích xuất các hàng mà phần tử ở cột 0 bằng 4
dieu_kien_hang = (ma_tran_so_lieu[:, 0] == 4)
print("Hàng có cột 0 bằng 4:\n", ma_tran_so_lieu[dieu_kien_hang])

8. Chuyển đổi kiểu dữ liệu

Bạn có thể chuyển đổi kiểu dữ liệu của các phần tử trong mảng bằng phương thức .astype().

mang_chuoi = np.array(["100", "200", "300", "400"])
print("Mảng chuỗi ban đầu:", mang_chuoi, mang_chuoi.dtype)

mang_so_thuc = mang_chuoi.astype(float)
print("Mảng số thực sau chuyển đổi:", mang_so_thuc, mang_so_thuc.dtype)

9. Các phép toán thống kê cơ bản

NumPy cung cấp nhiều hàm thống kê tích hợp sẵn như tổng, trung bình, giá trị lớn nhất/nhỏ nhất, v.v.

print("Tổng của mảng một chiều:", mang_mot_chieu.sum())
print("Giá trị trung bình của mảng một chiều:", mang_mot_chieu.mean())

# Tổng theo cột (axis=0)
print("Tổng theo cột của ma trận:\n", ma_tran_so_lieu.sum(axis = 0))
# Tổng theo hàng (axis=1)
print("Tổng theo hàng của ma trận:\n", ma_tran_so_lieu.sum(axis = 1))

10. Xử lý giá trị thiếu (NaN)

Bạn có thể phát hiện và thay thế các giá trị thiếu (Not a Number - NaN) trong mảng.

# Tạo một mảng ví dụ có giá trị NaN
du_lieu_kem_chat_luong = np.array([[10, 20, np.nan], [30, np.nan, 60], [np.nan, 80, 90]])
print("Dữ liệu ban đầu:\n", du_lieu_kem_chat_luong)

# Tìm vị trí các giá trị NaN
vi_tri_nan = np.isnan(du_lieu_kem_chat_luong)
print("Vị trí NaN:\n", vi_tri_nan)

# Thay thế các giá trị NaN bằng 0
du_lieu_kem_chat_luong[vi_tri_nan] = 0
print("Dữ liệu sau khi điền NaN:\n", du_lieu_kem_chat_luong)

11. Tạo mảng bằng arange và reshape

Hàm np.arange() tạo ra một mảng với các giá trị trong một khoảng nhất định, sau đó .reshape() được dùng để thay đổi kích thước của mảng.

# Tạo một mảng từ 0 đến 14 và định hình lại thành 3 hàng, 5 cột
ma_tran_moi = np.arange(15).reshape(3, 5)
print("Ma trận mới tạo:\n", ma_tran_moi)

12. Kiểm tra số chiều của mảng

Thuộc tính .ndim trả về số chiều của mảng.

print("Số chiều của ma trận mới:", ma_tran_moi.ndim)

13. Các thuộc tính mảng khác

Ngoài ndim và dtype, các thuộc tính hữu ích khác bao gồm .shape (kích thước của mỗi chiều) và .size (tổng số phần tử).

print("Kích thước ma trận (shape):", ma_tran_moi.shape)
print("Tổng số phần tử (size):", ma_tran_moi.size)

14. Tạo ma trận toàn số 0

Hàm np.zeros() tạo một mảng với tất cả các phần tử là 0.

ma_tran_khong = np.zeros((4, 3)) # 4 hàng, 3 cột
print("Ma trận toàn số 0:\n", ma_tran_khong)

15. Tạo ma trận toàn số 1

Hàm np.ones() tạo một mảng với tất cả các phần tử là 1.

# Tạo một mảng 3 chiều có kích thước 2x3x4 với kiểu dữ liệu int16
ma_tran_mot = np.ones((2, 3, 4), dtype = np.int16)
print("Ma trận toàn số 1 (3D):\n", ma_tran_mot)

16. Tạo mảng với bước nhảy xác định

Sử dụng np.arange(start, stop, step) để tạo một mảng với các giá trị từ start đến stop-1, tăng dần theo step.

day_so = np.arange(5, 20, 3) # Từ 5 đến dưới 20, bước nhảy 3
print("Dãy số có bước nhảy:\n", day_so)

17. Khởi tạo ma trận ngẫu nhiên

Hàm np.random.random() tạo một mảng với các số ngẫu nhiên phân phối đều trong khoảng [0.0, 1.0).

ma_tran_ngau_nhien = np.random.random((4, 5)) # 4 hàng, 5 cột
print("Ma trận ngẫu nhiên:\n", ma_tran_ngau_nhien)

18. Tạo mảng với các giá trị cách đều (linspace)

np.linspace(start, stop, num) tạo ra num số cách đều nhau trong khoảng từ start đến stop (bao gồm cả stop).

# Tạo 10 điểm cách đều từ 0 đến 1
diem_cach_deu = np.linspace(0, 1, 10)
print("Các điểm cách đều:\n", diem_cach_deu)

19. Tính toán hàm lượng giác

NumPy tích hợp nhiều hàm toán học, bao gồm các hàm lượng giác, có thể áp dụng trực tiếp lên toàn bộ mảng.

goc = np.linspace(0, np.pi, 5) # 5 góc từ 0 đến pi
gia_tri_sin = np.sin(goc)
print("Giá trị sin của các góc:\n", gia_tri_sin)

20. Các phép toán số học trên mảng

Các phép toán số học như cộng, trừ, nhân, chia, lũy thừa được thực hiện theo từng phần tử (element-wise) khi áp dụng cho mảng NumPy.

mang_a = np.array([10, 15, 20, 25])
mang_b = np.arange(4) # [0, 1, 2, 3]

print("mang_a:", mang_a)
print("mang_b:", mang_b)
print("mang_a - mang_b:", mang_a - mang_b)
print("mang_b mũ 2:", mang_b ** 2)
print("mang_a < 20:", mang_a < 20)

21. Tích vô hướng và tích ma trận

Phép nhân * thực hiện tích từng phần tử, trong khi .dot() hoặc np.dot() thực hiện tích ma trận (matrix multiplication).

mat_X = np.array([[1, 2], [3, 4]])
mat_Y = np.array([[5, 6], [7, 8]])

print("Ma trận X:\n", mat_X)
print("Ma trận Y:\n", mat_Y)

# Tích từng phần tử (element-wise product)
print("X * Y (từng phần tử):\n", mat_X * mat_Y)

# Tích ma trận (matrix product)
print("X dot Y (tích ma trận):\n", mat_X.dot(mat_Y))
# Hoặc sử dụng np.dot
print("np.dot(X, Y):\n", np.dot(mat_X, mat_Y))

22. Hàm mũ tự nhiên (e^x)

Sử dụng np.exp() để tính lũy thừa của e cho từng phần tử trong mảng.

mang_e = np.arange(3) # [0, 1, 2]
print("e mũ từng phần tử:\n", np.exp(mang_e))

23. Căn bậc hai

Hàm np.sqrt() tính căn bậc hai cho từng phần tử.

mang_can = np.array([1, 4, 9])
print("Căn bậc hai từng phần tử:\n", np.sqrt(mang_can))

24. Làm tròn xuống (Floor)

Hàm np.floor() làm tròn xuống số nguyên gần nhất cho từng phần tử.

ma_tran_ngau_nhien_floor = np.floor(10 * np.random.random((3, 4)))
print("Ma trận sau khi làm tròn xuống:\n", ma_tran_ngau_nhien_floor)

25. Làm phẳng mảng (Flattening)

Phương thức .ravel() trả về một mảng phẳng (một chiều) của mảng gốc.

mang_phang = ma_tran_ngau_nhien_floor.ravel()
print("Mảng phẳng:\n", mang_phang)

26. Thay đổi kích thước mảng bằng cách gán thuộc tính .shape

Bạn có thể thay đổi hình dạng của mảng trực tiếp bằng cách gán một tuple mới cho thuộc tính .shape.

# Giả sử ma_tran_ngau_nhien_floor có kích thước (3, 4) = 12 phần tử
# Thay đổi thành (2, 6)
ma_tran_ngau_nhien_floor.shape = (2, 6)
print("Ma trận sau khi thay đổi shape:\n", ma_tran_ngau_nhien_floor)

27. Chuyển vị ma trận (Transpose)

Thuộc tính .T hoặc hàm np.transpose() thực hiện chuyển vị ma trận (đổi hàng thành cột và ngược lại).

ma_tran_chuyen_vi = ma_tran_ngau_nhien_floor.T
print("Ma trận chuyển vị:\n", ma_tran_chuyen_vi)

28. Các phương thức định hình lại khác (reshape, resize)

.reshape() trả về một mảng mới với hình dạng đã cho, trong khi .resize() thay đổi kích thước mảng tại chỗ.

mang_goc = np.arange(12)
print("Mảng gốc:", mang_goc)

# reshape: trả về một mảng mới
mang_moi_reshape = mang_goc.reshape(3, 4)
print("Mảng sau reshape:\n", mang_moi_reshape)

# resize: thay đổi tại chỗ
mang_goc.resize((2, 6))
print("Mảng gốc sau resize:\n", mang_goc)

# Sử dụng -1 để NumPy tự động tính toán kích thước chiều đó
mang_tu_dong_hinh = mang_moi_reshape.reshape(2, -1)
print("Mảng tự động hình:\n", mang_tu_dong_hinh)

29. Ghép nối mảng (Stacking)

np.vstack() ghép các mảng theo chiều dọc (thêm hàng), np.hstack() ghép theo chiều ngang (thêm cột).

mat_A = np.floor(10 * np.random.random((2, 3)))
mat_B = np.floor(10 * np.random.random((2, 3)))

print("Ma trận A:\n", mat_A)
print("Ma trận B:\n", mat_B)

# Ghép theo chiều dọc
ghe_p_doc = np.vstack((mat_A, mat_B))
print("Ghép dọc:\n", ghe_p_doc)

# Ghép theo chiều ngang
ghe_p_ngang = np.hstack((mat_A, mat_B))
print("Ghép ngang:\n", ghe_p_ngang)

30. Chia mảng (Splitting)

np.hsplit() chia mảng theo chiều ngang (theo cột), np.vsplit() chia theo chiều dọc (theo hàng).

mat_lon_ngang = np.floor(10 * np.random.random((3, 9)))
print("Ma trận lớn ngang:\n", mat_lon_ngang)

# Chia thành 3 phần bằng nhau theo chiều ngang
chia_ngang_ba_phan = np.hsplit(mat_lon_ngang, 3)
print("Chia ngang 3 phần:\n", chia_ngang_ba_phan)

# Chia theo các chỉ số cột (cắt tại cột 2 và 5)
chia_ngang_chi_so = np.hsplit(mat_lon_ngang, (2, 5))
print("Chia ngang theo chỉ số (cắt tại 2, 5):\n", chia_ngang_chi_so)

mat_lon_doc = np.floor(10 * np.random.random((9, 2)))
print("Ma trận lớn dọc:\n", mat_lon_doc)

# Chia thành 3 phần bằng nhau theo chiều dọc
chia_doc_ba_phan = np.vsplit(mat_lon_doc, 3)
print("Chia dọc 3 phần:\n", chia_doc_ba_phan)

31. Sự khác biệt giữa tham chiếu, view và copy

Khi gán mảng, cần hiểu rõ NumPy xử lý tham chiếu, view (cùng dữ liệu, khác đối tượng) và copy (độc lập hoàn toàn).

mang_nguyen_thuy = np.arange(10)
print("ID của mang_nguyen_thuy:", id(mang_nguyen_thuy))

# Gán tham chiếu (reference)
tham_chieu = mang_nguyen_thuy
print("tham_chieu là mang_nguyen_thuy?", tham_chieu is mang_nguyen_thuy)
print("ID của tham_chieu:", id(tham_chieu))
tham_chieu[0] = 99 # Thay đổi tham_chieu cũng thay đổi mang_nguyen_thuy
print("mang_nguyen_thuy sau thay đổi tham_chieu:", mang_nguyen_thuy)

# Tạo một view (chế độ xem) - chia sẻ dữ liệu nhưng là đối tượng khác
che_do_xem = mang_nguyen_thuy.view()
print("che_do_xem là mang_nguyen_thuy?", che_do_xem is mang_nguyen_thuy)
print("ID của che_do_xem:", id(che_do_xem))
che_do_xem[1] = 88 # Thay đổi che_do_xem cũng thay đổi mang_nguyen_thuy
print("mang_nguyen_thuy sau thay đổi che_do_xem:", mang_nguyen_thuy)

# Tạo một bản sao (copy) - hoàn toàn độc lập
ban_sao = mang_nguyen_thuy.copy()
print("ban_sao là mang_nguyen_thuy?", ban_sao is mang_nguyen_thuy)
print("ID của ban_sao:", id(ban_sao))
ban_sao[2] = 77 # Thay đổi ban_sao không ảnh hưởng đến mang_nguyen_thuy
print("mang_nguyen_thuy sau thay đổi ban_sao:", mang_nguyen_thuy)

32. Tìm giá trị lớn nhất và chỉ số

.max() tìm giá trị lớn nhất, .argmax() tìm chỉ số của giá trị lớn nhất theo một trục cụ thể.

du_lieu_mau = np.array([[1, 5, 2], [8, 3, 7], [4, 9, 6]])
print("Dữ liệu mẫu:\n", du_lieu_mau)

# Giá trị lớn nhất trên toàn bộ mảng
print("Giá trị lớn nhất toàn bộ:", du_lieu_mau.max())

# Giá trị lớn nhất theo cột (axis=0)
print("Giá trị lớn nhất theo cột:", du_lieu_mau.max(axis = 0))

# Chỉ số của giá trị lớn nhất theo hàng (axis=1)
print("Chỉ số lớn nhất theo hàng:", du_lieu_mau.argmax(axis = 1))

33. Sắp xếp mảng

np.sort() trả về một mảng đã sắp xếp mà không thay đổi mảng gốc. Phương thức .sort() sắp xếp mảng tại chỗ.

ma_tran_can_sap_xep = np.floor(10 * np.random.random((3, 4)))
print("Ma trận ban đầu:\n", ma_tran_can_sap_xep)

# Sắp xếp theo cột (axis=0)
print("Sắp xếp theo cột:\n", np.sort(ma_tran_can_sap_xep, axis = 0))

# Sắp xếp theo hàng (axis=1)
print("Sắp xếp theo hàng (không thay đổi gốc):\n", np.sort(ma_tran_can_sap_xep, axis = 1))

# Sắp xếp tại chỗ (axis=1)
ma_tran_can_sap_xep.sort(axis = 1)
print("Ma trận sau khi .sort() tại chỗ:\n", ma_tran_can_sap_xep)

34. Lặp lại mảng (Tile)

Hàm np.tile(A, reps) xây dựng một mảng bằng cách lặp lại mảng A một số lần được chỉ định bởi reps.

mang_goc_tile = np.array([0, 10, 20])
print("Mảng gốc để tile:", mang_goc_tile)

# Lặp lại 2 lần theo hàng, 3 lần theo cột
mang_tile = np.tile(mang_goc_tile, (2, 3))
print("Mảng sau khi tile:\n", mang_tile)

35. Tạo ma trận bàn cờ

Sử dụng kỹ thuật cắt lát với bước nhảy để tạo ra các mẫu phức tạp như bàn cờ.

ban_co = np.zeros((8, 8), dtype = int)
# Đặt 1 vào các ô hàng lẻ, cột chẵn
ban_co[1::2, ::2] = 1
# Đặt 1 vào các ô hàng chẵn, cột lẻ
ban_co[::2, 1::2] = 1
print("Ma trận bàn cờ:\n", ban_co)

36. Gán đa giá trị từ hàm

Bạn có thể gán nhiều biến cùng lúc với kết quả của các hàm trả về nhiều giá trị hoặc từ các thuộc tính mảng.

du_lieu_ngau_nhien = 100 * np.random.random((5, 5))
gia_tri_min, gia_tri_max = du_lieu_ngau_nhien.min(), du_lieu_ngau_nhien.max()
print("Dữ liệu ngẫu nhiên:\n", du_lieu_ngau_nhien)
print(f"Giá trị nhỏ nhất: {gia_tri_min:.2f}, Giá trị lớn nhất: {gia_tri_max:.2f}")

37. Chuẩn hóa dữ liệu (Min-Max Scaling)

Chuẩn hóa dữ liệu về khoảng [0, 1] là một kỹ thuật phổ biến trong xử lý dữ liệu.

du_lieu_chua_chuan_hoa = 10 * np.random.random((4, 4))
print("Dữ liệu chưa chuẩn hóa:\n", du_lieu_chua_chuan_hoa)

min_val, max_val = du_lieu_chua_chuan_hoa.min(), du_lieu_chua_chuan_hoa.max()
du_lieu_chuan_hoa = (du_lieu_chua_chuan_hoa - min_val) / (max_val - min_val)
print("Dữ liệu sau khi chuẩn hóa (0-1):\n", du_lieu_chuan_hoa)

38. Broadcasting trong phép toán mảng

Broadcasting là cơ chế của NumPy cho phép thực hiện các phép toán trên các mảng có hình dạng khác nhau.

ma_tran_goc = np.zeros((3, 5))
print("Ma trận gốc (3x5):\n", ma_tran_goc)

mang_them = np.arange(5) # [0, 1, 2, 3, 4]
print("Mảng được thêm (1x5):\n", mang_them)

# mang_them được "broadcast" tới mỗi hàng của ma_tran_goc
ma_tran_goc += mang_them
print("Ma trận sau khi cộng với mảng (Broadcasting):\n", ma_tran_goc)

39. Tạo mảng linspace với thông tin bổ sung

np.linspace() có thể trả về bước nhảy (retstep=True) và điều khiển việc bao gồm điểm cuối (endpoint=True/False).

# Tạo 11 số từ 0 đến 10 (bao gồm 0 và 10), trả về cả bước nhảy
day_so_va_buoc_nhay, buoc = np.linspace(0, 10, 11, endpoint=True, retstep=True)
print("Dãy số:", day_so_va_buoc_nhay)
print("Bước nhảy:", buoc)

40. Hoán đổi hai hàng trong ma trận

Bạn có thể hoán đổi các hàng của một ma trận một cách hiệu quả bằng cách sử dụng chỉ mục nâng cao.

ma_tran_hoan_doi = np.arange(25).reshape(5, 5)
print("Ma trận ban đầu:\n", ma_tran_hoan_doi)

# Hoán đổi hàng 0 và hàng 1
ma_tran_hoan_doi[[0, 1]] = ma_tran_hoan_doi[[1, 0]]
print("Ma trận sau khi hoán đổi hàng 0 và 1:\n", ma_tran_hoan_doi)

41. Tìm giá trị gần nhất trong mảng

Để tìm giá trị trong mảng gần nhất với một số cho trước, bạn có thể tính độ lệch tuyệt đối và tìm chỉ số của giá trị nhỏ nhất.

du_lieu_tim_kiem = np.array([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]])
gia_tri_muc_tieu = 5.7

# Tính độ lệch tuyệt đối giữa mỗi phần tử và giá trị mục tiêu
do_lech_tuyet_doi = np.abs(du_lieu_tim_kiem - gia_tri_muc_tieu)
# Tìm chỉ số của độ lệch nhỏ nhất
chi_so_gan_nhat = do_lech_tuyet_doi.argmin()

print("Dữ liệu tìm kiếm:\n", du_lieu_tim_kiem)
print("Giá trị mục tiêu:", gia_tri_muc_tieu)
# Sử dụng flat để truy cập phần tử bằng chỉ số phẳng
print("Giá trị gần nhất:", du_lieu_tim_kiem.flat[chi_so_gan_nhat])

42. Kiểm tra cột chứa toàn số 0

Sử dụng .any(axis=0) để kiểm tra xem có bất kỳ giá trị khác 0 nào trong mỗi cột không. Nếu một cột chứa toàn số 0, kết quả cho cột đó sẽ là False.

ma_tran_kiem_tra = np.array([[1, 0, 3], [0, 0, 5], [7, 0, 9]])
print("Ma trận kiểm tra:\n", ma_tran_kiem_tra)

# Kiểm tra xem có bất kỳ phần tử khác 0 nào theo cột không
# Nếu tất cả phần tử trong một cột là 0, thì cột đó là False
co_bat_ky_khac_khong = ma_tran_kiem_tra.any(axis = 0)
print("Có bất kỳ giá trị khác 0 nào theo cột không:", co_bat_ky_khac_khong)

# Để kiểm tra nếu có một cột hoàn toàn là 0, chúng ta cần tìm nơi mà 'any' trả về False.
cot_hoan_toan_khong = ~co_bat_ky_khac_khong
print("Các cột hoàn toàn là 0:", cot_hoan_toan_khong)

43. Tạo ma trận Gaussian 2D

Tạo một ma trận Gaussian 2 chiều thường được sử dụng trong xử lý ảnh và các mô phỏng khoa học.

# Tạo lưới tọa độ x và y
x_coords = np.linspace(-1.5, 1.5, 15)
y_coords = np.linspace(-1.5, 1.5, 15)
X, Y = np.meshgrid(x_coords, y_coords)

# Tính khoảng cách từ tâm (0,0)
khoang_cach_binh_phuong = X**2 + Y**2

# Các tham số cho hàm Gaussian
sigma = 0.5 # Độ lệch chuẩn
mu = 0.0    # Giá trị trung bình (tâm của phân phối)

# Áp dụng công thức hàm Gaussian 2D
ma_tran_gaussian = np.exp(-(khoang_cach_binh_phuong - mu)**2 / (2 * sigma**2))
print("Ma trận Gaussian 2D (kích thước 15x15):\n", ma_tran_gaussian)