Numpy Cơ Bản

---

NumPy là một thư viện Python mạnh mẽ, cung cấp công cụ xử lý mảng đa chiều và các hàm toán học hiệu quả. Nó tối ưu hóa tốc độ, bộ nhớ và tích hợp tốt với các thư viện như Pandas, Matplotlib, giúp hỗ trợ đắc lực cho khoa học dữ liệu và học máy.

1. Giới thiệu về Numpy.

• NumPy là một thư viện Python được sử dụng để làm việc với mảng, đồng thời cung cấp các hàm hỗ trợ trong các lĩnh vực như đại số tuyến tính, biến đổi Fourier và ma trận. Được tạo ra vào năm 2005 bởi Travis Oliphant, NumPy là một dự án mã nguồn mở và hoàn toàn miễn phí. Tên gọi “NumPy” là viết tắt của “Numerical Python”.
• Trong Python, chúng ta có danh sách (list) phục vụ mục đích tương tự như mảng, nhưng tốc độ xử lý chậm. NumPy được thiết kế để cung cấp một đối tượng mảng nhanh hơn danh sách thông thường của Python lên đến 50 lần. Đối tượng mảng trong NumPy được gọi là ndarray, đi kèm với nhiều hàm hỗ trợ giúp việc làm việc với nó trở nên dễ dàng hơn. Mảng được sử dụng rất phổ biến trong khoa học dữ liệu, nơi tốc độ và tài nguyên đóng vai trò rất quan trọng.
• Mảng NumPy được lưu trữ trong một vùng nhớ liên tục, không giống như danh sách (list), giúp các tiến trình truy cập và xử lý dữ liệu rất hiệu quả. Hành vi này được gọi là locality of reference trong khoa học máy tính. Đây là lý do chính khiến NumPy nhanh hơn danh sách, và thư viện này cũng được tối ưu hóa để tận dụng các kiến trúc CPU hiện đại.

2. Cách cài đặt.

• Đảm bảo bạn đã tạo một môi trường ảo, bạn có thể dùng câu lệnh ở dưới để tải numpy:

pip install numpy

• Nếu bạn muốn tải Numpy trên Google Colab, Kaggle NoteBook,… thì bạn có thể dùng câu lệnh dưới đây, chỉ cần thêm dấu ! đằng trước câu lệnh trên:

!pip install numpy

3. Các hàm cơ bản trong Numpy.

• Vì Numpy là một thư viện trong python nên trước khi sử dụng thì chúng ta phải import nó:

import numpy
a = numpy.array([1,2,3,4,5])
print(a)

[1 2 3 4 5]

• Numpy thường được viết tắt là np:

import numpy as np
a = np.array([1,2,3])
print(a)

[1,2,3]

• Bạn có thể kiểm tra phiên bản của Numpy bằng:

import numpy as np
print(np.__version__)

1.26.4

Tạo mảng trong numpy

• NumPy được sử dụng để làm việc với mảng, với đối tượng mảng được gọi là ndarray. Chúng ta có thể tạo một đối tượng ndarray của NumPy bằng cách sử dụng hàm array():

import numpy as np
a = np.array([1,2,3,4,5])
print(a)
print(type(a))

[1 2 3 4 5]

<class ‘numpy.ndarray’>

• Để tạo một ndarray, chúng ta có thể truyền một danh sách (list), bộ dữ liệu (tuple) hoặc bất kỳ đối tượng tương tự mảng nào vào phương thức array(), và nó sẽ được chuyển đổi thành một ndarray. Ví dụ dưới là truyền vào một tuple:

import numpy as np
arr = np.array((1, 2, 3, 4, 5))
print(arr)

[1 2 3 4 5]

Chiều ở trong mảng

• Scalar: Là một giá trị số đơn lẻ, không có hướng. Ví dụ: 5, 3.14.
• Vector: Là một mảng một chiều gồm các số, biểu diễn độ lớn và hướng. Ví dụ: [2, 4, 6].
• Matrix: Là một mảng hai chiều, là ma trận, có hàng và cột. Ví dụ:
• \[\begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix}\]

• Tensor: Là một khái quát hóa của mảng đa chiều, nhiều hơn hai chiều. Ví dụ: rubik là hình lập phương dữ liệu 3D.

• Tạo ra mảng 0 chiều (Scalar) trong numpy:

import numpy as np
arr = np.array(42)
print(arr)

42

• Tạo mảng 1 chiều (Vector) trong numpy:

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr)

[1 2 3 4 5]

• Tạo mảng 2 chiều (Matrix) trong numpy:

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr)

[[1 2 3]

[4 5 6]]

• Tạo mảng 3 chiều (Tensor) trong numpy:

import numpy as np
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])
print(arr)

[[[1 2 3]

[4 5 6]]

[[1 2 3]

[4 5 6]]]

• Bạn có thể tính số chiều của mảng bằng hàm ndim:

import numpy as np

a = np.array(42)
b = np.array([1, 2, 3, 4, 5])
c = np.array([[1, 2, 3], [4, 5, 6]])
d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])

print(a.ndim)
print(b.ndim)
print(c.ndim)
print(d.ndim)

0

1

2

3

• Bạn có thể tạo ra mảng có số chiều bất kỳ bằng tham số ndmin:

import numpy as np 
a = np.array([1,2,3,4], ndmin = 4)
print(a)
print(a.ndim)

[[[[1 2 3 4]]]]

4

Truy cập chỉ số trong mảng

• Bạn có thể truy cập chỉ số trong mảng ở numpy như mảng thông thường, chỉ số bắt đầu từ 0:

import numpy as np
arr = np.array([1, 2, 3, 4])
print(arr[0])

1

• Hãy thử truy cập chỉ số ở mảng hai chiều:

import numpy as np
arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])
print('5th element on 2nd row: ', arr[1, 4]) # hoặc arr[1][4]

5th element on 2nd row: 10

• Hãy thử ở mảng ba chiều:

import numpy as np
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print(arr[0, 1, 2]) # hoặc arr[0][1][2]

6

NumPy Array Slicing

• Slicing trong Python có nghĩa là lấy các phần tử từ một chỉ số bắt đầu đến một chỉ số kết thúc nhất định. Cú pháp cơ bản của slicing là:

[start:end]

• start: Chỉ số bắt đầu (bao gồm).

• end: Chỉ số kết thúc (không bao gồm).

• Ngoài ra, bạn có thể chỉ định step (bước nhảy) bằng cách sử dụng cú pháp sau:

[start:end:step]

• start: Nếu không truyền giá trị, mặc định sẽ là 0.
• end: Nếu không truyền giá trị, mặc định sẽ là chiều dài của mảng ở chiều đó.

• step: Nếu không truyền giá trị, mặc định sẽ là 1.

• Xem ví dụ dưới đây:

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[1:5])
print(arr[2:])
print(arr[:4])

[2 3 4 5]

[3 4 5 6 7]

[1 2 3 4]

• Bạn có thể dùng chỉ số âm, -1 có nghĩa là phần tử ở cuối, -2 là phần tử thứ 2 từ cuối lên đầu. Hãy coi phần tử đầu tiên có chỉ số là 0, các chỉ số âm sẽ giống như kiểu vòng lại lên cuối:

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[-3:-1])

[5 6]

• Dùng step để làm bước nhảy:

import numpy as np

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

print(arr[1:5:2])
print(arr[::2])

[2 4]

[1 3 5 7]

Kiểu dữ liệu trong Numpy

• NumPy có một số kiểu dữ liệu đặc biệt và sử dụng các ký tự đơn để đại diện cho chúng, ví dụ như i cho số nguyên, u cho số nguyên không dấu, v.v.

• Dưới đây là danh sách tất cả các kiểu dữ liệu trong NumPy và ký tự tương ứng để đại diện:
  • i - số nguyên (integer)
  • b - boolean (logic)
  • u - số nguyên không dấu (unsigned integer)
  • f - số thực (float)
  • c - số thực phức (complex float)
  • m - thời gian (timedelta)
  • M - ngày giờ (datetime)
  • O - đối tượng (object)
  • S - chuỗi (string)
  • U - chuỗi Unicode (unicode string)
  • V - vùng nhớ cố định cho kiểu dữ liệu khác (void)
• Giờ hãy thử kiểm tra kiểu dữ liệu bằng hàm dtype:

import numpy as np
arr = np.array([1,2,3,4])
print(arr.dtype)

int64

import numpy as np
arr = np.array(['apple', 'banana', 'cherry'])
print(arr.dtype) # in ra <U6, số 6 có nghĩa có tối đa 6 kí tự trong 1 xâu

<U6

• Giờ hãy thử tạo một mảng mà ta sẽ tự định nghĩa kiểu dữ liệu của mảng đó:

import numpy as np
arr = np.array([1, 2, 3, 4], dtype='S')
print(arr)
print(arr.dtype)

[b’1’ b’2’ b’3’ b’4’]

S1

• Giờ hãy thử ép kiểu từ 1 mảng đã có sẵn bằng hàm astype:

import numpy as np
a = np.array([1.1, 2.1, 3.1])
b = a.astype('i')
print(b)
print(b.dtype)

[1 2 3]

int32

• Bạn có thể ép kiểu dùng tham số int như dưới đây:

import numpy as np

arr = np.array([1.1, 2.1, 3.1])

newarr = arr.astype(int)

print(newarr)
print(newarr.dtype)

[1 2 3]

int64

Copy và View trong Numpy

• Hiểu đơn giản thì hàm copy sẽ tạo ra một bản sao không liên quan gì đến mảng cũ. Còn hàm view thì đúng như cái tên, nó chỉ tạo ra một mảng mới “nhìn” vào mảng cũ. Khi thay đổi mảng cũ thì dùng hàm copy sẽ không thay đổi mảng mới, nhưng dùng hàm view thì sẽ thay đổi vì đơn giản là mảng mới đang “nhìn” mảng cũ nên mảng cũ thay đổi sao thì mảng mới cũng như vậy. Tưởng tượng hàm view chính là 1 chiếc gương:

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
x = arr.copy()
arr[0] = 42
print(arr)
print(x)

[42 2 3 4 5] [1 2 3 4 5]

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
x = arr.view()
arr[0] = 42
print(arr)
print(x)

[42 2 3 4 5]

[42 2 3 4 5]

Shape trong Numpy

• Shape của 1 mảng là số của từng chiều trong mảng đó. Numpy sử dụng hàm shape để lấy ra số của từng chiều:

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
print(arr.shape)

(2, 4)

• Ra kết quả như trên vì mảng có hai chiều, chiều thứ nhất có 2 phần tử (tượng trưng cho hai hàng), chiều thứ hai có 4 phần tử (tượng trưng cho bốn cột). Xem ví dụ tiếp dưới đây:

import numpy as np

arr = np.array([1, 2, 3, 4], ndmin=5)

print(arr)
print('shape of array :', arr.shape)

[[[[[1 2 3 4]]]]]

shape of array : (1, 1, 1, 1, 4)

• Hãy thử suy nghĩ tại sao kết quả lại ra vậy. Chúng ta có thể thay đổi kích cỡ chiều, cũng như số chiều bằng hàm reshape. Xem các ví dụ dưới:

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
newarr = arr.reshape(4, 3)
print(newarr)

[[ 1 2 3]

[ 4 5 6]

[ 7 8 9]

[10 11 12]]

import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

newarr = arr.reshape(2, 3, 2)

print(newarr)

[[[ 1 2]

[ 3 4]

[ 5 6]]

[[ 7 8]

[ 9 10]

[11 12]]]

• Chú ý rằng, chúng ta chỉ có thể thay đổi số chiều khi tích số trong các chiều bằng đúng với số lượng phần tử trong mảng ban đầu. Thêm một điều nữa là reshape sẽ trả về mảng dạng view, nên khi thay đổi mảng cũ thì mảng mới cũng sẽ thay đổi:

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
newarr = arr.reshape(4, 3)
arr[0] = 100
print(newarr)

[[100 2 3]

[ 4 5 6]

[ 7 8 9]

[ 10 11 12]]

• Bạn có thể không cần đưa trước một chiều cụ thể nếu như bạn lười tính toán. Bạn có thể để chiều đấy là -1 và Numpy sẽ tự động tính cho bạn:

import numpy as np

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

newarr = arr.reshape(2, 2, -1)

print(newarr)

[[[1 2]

[3 4]]

[[5 6]

[7 8]]]

• Tất nhiên bạn không thể -1 ở hai chiều được. Bạn có thể làm phẳng (flattening) mảng bằng hàm flatten() hoặc chỉ đơn giản là dùng reshape(-1):

import numpy as np

# Tạo mảng 2 chiều
arr = np.array([[1, 2, 3], [4, 5, 6]])

# Làm phẳng mảng
flattened_arr = arr.flatten() # hoặc arr.reshape(-1)

print(flattened_arr)

[1 2 3 4 5 6]

• Dưới đây là cách duyệt qua các phần tử trong Numpy sử dụng vòng lặp for:

import numpy as np

arr = np.array([1, 2, 3])

for x in arr:
  print(x, end = " ")
print()
for i in range(len(arr)):
  print(arr[i], end = " ")

1 2 3

1 2 3

Kết hợp mảng trong Numpy

• Để kết hợp hai bảng với nhau, chúng ta có thể sử dụng hàm concatenate với tham số axis. Nếu không truyền axis thì mặc định là 0:

import numpy as np
arr1 = np.array([1,2,3])
arr2 = np.array([4,5,6])
arr = np.concatenate((arr1, arr2))
print(arr)

[1 2 3 4 5 6]

• Nếu ta muốn kết hợp mảng 2 chiều thì nên thêm tham số axis, axis = 0 là kết hợp theo hàng, axis = 1 là kết hợp theo cột:

import numpy as np

# Tạo hai mảng 2D
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])

# Sử dụng concatenate để kết hợp mảng theo trục 0
result = np.concatenate((arr1, arr2), axis=0)
print(result)

[[ 1 2 3]

[ 4 5 6]

[ 7 8 9]

[10 11 12]]

import numpy as np

# Tạo hai mảng 2D
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])

# Sử dụng concatenate để kết hợp mảng theo trục 1
result = np.concatenate((arr1, arr2), axis=1)
print(result)

[[ 1 2 3 7 8 9]

[ 4 5 6 10 11 12]]

-Hàm stack giống như concatenation, điểm khác biệt duy nhất là stack được thực hiện theo một trục mới, tức là sẽ tạo ra 1 chiều mới, stack cũng có tham số axis, mặc định axis = 0:

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
arr = np.stack((arr1, arr2), axis=0)
print(arr)

[[1 2 3]

[4 5 6]]

import numpy as np

arr1 = np.array([1, 2, 3])

arr2 = np.array([4, 5, 6])

arr = np.stack((arr1, arr2), axis=1)
print(arr)

[[1 4]

[2 5]

[3 6]]

4. Tổng Kết.

NumPy là công cụ quan trọng không thể thiếu trong lĩnh vực AI nhờ khả năng xử lý mảng và ma trận hiệu quả. Với các phép toán toán học mạnh mẽ và khả năng làm việc với dữ liệu lớn, NumPy là nền tảng vững chắc cho các thư viện như TensorFlow, PyTorch và Scikit-learn. Trong AI, NumPy giúp tối ưu hóa quá trình tính toán, xây dựng và huấn luyện mô hình học máy, là công cụ thiết yếu để phát triển các giải pháp AI mạnh mẽ và hiệu quả.