20 câu hỏi phỏng vấn NumPy hàng đầu: Từ cơ bản đến nâng cao

Câu hỏi phỏng vấn NumPy trung cấp

Những câu hỏi này đi sâu hơn vào cách sử dụng NumPy. Khi bạn đã nắm vững nền tảng về mảng của NumPy, hãy khám phá các chức năng của nó. Ở mức trung cấp, bạn được kỳ vọng có thể thực hiện các phép tính với NumPy.

6. Làm thế nào để tạo mảng toàn số 0 hoặc toàn số 1?

Tạo mảng toàn số 0 hoặc số 1 là yêu cầu phổ biến trong nhiều tác vụ khoa học dữ liệu, như khởi tạo ma trận, tạo mảng mặt nạ hoặc thiết lập cấu trúc dữ liệu giữ chỗ. 

Để tạo mảng toàn số 0 hoặc số 1 trong NumPy, bạn dùng hàm np.zeros() hoặc np.ones():

import numpy as np

# Create a 3x4 array of zeros
zeros_arr = np.zeros((3, 4))
print(zeros_arr)
# Output:
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

# Create a 2x2 array of ones
ones_arr = np.ones((2, 2))
print(ones_arr)
# Output:
# [[1. 1.]
#  [1. 1.]]

7. Broadcasting trong NumPy là gì?

Broadcasting là một hành vi quan trọng của NumPy cho phép vận hành hiệu quả trên các mảng có kích thước khác nhau. 

Nói đơn giản, nó cho phép thực hiện các phép toán số học giữa các mảng có kích thước khác nhau bằng cách đảm bảo cả hai mảng có shape tương thích. Điều này được thực hiện khi NumPy tự động nhân bản mảng nhỏ hơn trên mảng lớn hơn để chúng có shape tương thích. 

Xem ví dụ sau:

import numpy as np

a = np.array([1, 2, 3])b = np.array([[1], [2], [3]])
print(a + b)
# Output:
# [[2 3 4]
#  [3 4 5]
#  [4 5 6]]

8. Làm thế nào để tìm giá trị trung bình, trung vị và độ lệch chuẩn của một mảng NumPy?

Trung bình, trung vị và độ lệch chuẩn là các thống kê mô tả chủ chốt thường dùng để hiểu dữ liệu. NumPy tính toán những giá trị này rất dễ dàng và có hàm dựng sẵn cho chúng. 

Biết các phép tính này là quan trọng để tăng khả năng khai thác NumPy của chúng ta:

import numpy as np

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

# Mean
mean_value = np.mean(arr)
print("Mean:", mean_value)  # Output: 3.0

# Median
median_value = np.median(arr)
print("Median:", median_value)  # Output: 3.0

# Standard deviation
std_value = np.std(arr)
print("Standard deviation:", std_value)  # Output: 1.4142135623730951

9. Làm sao dùng NumPy để nhanh chóng truy vấn dữ liệu số và thực hiện hành động dựa trên một biểu thức boolean?

Dù mục đích chính của NumPy được xem là tính toán, nó cũng có khả năng xử lý dữ liệu mạnh mẽ. 

NumPy có thể truy vấn dữ liệu dễ dàng thông qua lập chỉ mục boolean và thực hiện các phép toán dựa trên kết quả. Phương thức where() đặc biệt hữu ích khi chúng ta muốn thay đổi dữ liệu dựa trên giá trị số.

Giả sử chúng ta có một data frame điểm thi tên là df và muốn phân loại học sinh. Một np.where() đơn giản có thể như sau:

df[‘student_cat’] = np.where(df[‘score’] > 80, ‘good’, ‘bad’)

Lưu ý rằng phương thức where() nhận tối đa 3 đầu vào: 

• Đầu tiên là biểu thức boolean bất kỳ
• Thứ hai là kết quả nếu đúng
• Thứ ba là kết quả nếu sai

10. Có cách nào sử dụng NumPy cho những thứ như Mean Squared Error không?

Khả năng làm việc trên toàn bộ mảng cùng lúc của NumPy giúp triển khai các phép tính như Mean Squared Error (MSE) trở nên đơn giản. 

Vì nó thực hiện các phép toán cơ bản theo từng phần tử nên dễ dàng vector hóa thao tác và cung cấp cách hiệu quả để tính MSE. 

Ví dụ triển khai MSE trong NumPy như sau:

# 1. We have two arrays, our prediction, and actual labels
# 2. We take the squared differences and sum them
# 3. We then divide by n, which is the length of the array

n= len(labels)
error = (1/n) * np.sum(np.square(predictions - labels))

Câu hỏi phỏng vấn NumPy nâng cao

Giờ là lúc bước vào phần nâng cao! Ở mức này, bạn được kỳ vọng sử dụng NumPy để giải quyết các vấn đề phức tạp hơn.

11. Làm sao tính các thống kê trượt bằng NumPy, như trung bình trượt?

Các thống kê trượt như trung bình trượt rất quan trọng trong khoa học dữ liệu. Trung bình trượt thường dùng để làm mượt dữ liệu nhiễu, đặc biệt khi theo thời gian. 

Một chức năng ít được biết đến của NumPy là “strides”. Một cách triển khai strides là tạo một cửa sổ trượt của mảng. Dùng lib.stride_tricks.sliding_window_view(), bạn có thể dễ dàng tạo các tập con của mảng. 

Sau đó, bạn có thể thực hiện bất kỳ phép tóm tắt nào, như tính trung bình, trên mỗi tập con để thu được trung bình trượt. Ví dụ triển khai:

import numpy as np

from numpy.lib.stride_tricks import sliding_window_view
x = np.arange(6)
v = sliding_window_view(x, 3)
# This creates v, an array that contains subarrays of length 3 which reflect the size of the window.

12. Làm thế nào để thực hiện lập chỉ mục nâng cao để chọn phần tử từ mảng đa chiều dựa trên điều kiện?

Trong khi lập chỉ mục có thể là kỹ năng nền tảng cho NumPy, khai thác các kỹ thuật lập chỉ mục nâng cao hơn có thể giúp nhà khoa học dữ liệu cắt lát dữ liệu chính xác hơn. 

Bằng cách sử dụng lập chỉ mục mảng số nguyên và lập chỉ mục boolean, việc tạo tập dữ liệu đáp ứng tiêu chí cụ thể trở nên đơn giản.

import numpy as np

array = np.array([[10, 15, 20, 25],
                  [30, 35, 40, 45],
                  [50, 55, 60, 65]])
print(array)  # Output: 
# [[10 15 20 25]
#  [30 35 40 45]
#  [50 55 60 65]]

# Boolean indexing: Select elements greater than 30
condition = array > 30
print(condition)  # Output:
# [[False False False False]
#  [False  True  True  True]
#  [ True  True  True  True]]

# Apply the condition to get the elements that meet the criteria
filtered_elements = array[condition]
print(filtered_elements)  # Output: [35 40 45 50 55 60 65]

# Integer array indexing: Select specific elements based on row and column indices
row_indices = np.array([0, 1, 2])
col_indices = np.array([1, 2, 3])
selected_elements = array[row_indices, col_indices]
print(selected_elements)  # Output: [15 40 65]

# Combining boolean and integer indexing
# Select elements from the array where the element is greater than 30 and belongs to specific indices
combined_condition = (array > 30) & ((row_indices[:, None] == np.arange(3)).any(axis=0))
filtered_selected_elements = array[combined_condition]
print(filtered_selected_elements)  # Output: [35 40 45 50 55 60 65]

13. Làm sao dùng NumPy để thực hiện phép đại số tuyến tính như phân rã ma trận hoặc giải hệ phương trình tuyến tính?

Thực hiện phân rã ma trận là điều sống còn cho nhà khoa học dữ liệu làm việc với khối lượng lớn dữ liệu. Giảm dữ liệu về các thành phần chính là bước đầu quan trọng để giảm độ phức tạp và nhiễu. 

Mô-đun linalg của NumPy cho phép chúng ta dễ dàng thực hiện đại số tuyến tính để thu được các thành phần chính. 

# The underlying signal is a sinusoidally modulated image
img = lena() # This is from scipy.misc import lena
t = np.arange(100)
time = np.sin(0.1*t)
true= time[:,np.newaxis,np.newaxis] * img[np.newaxis,...]

# We add some noise
noisy = real + np.random.randn(*true.shape)*255

# (observations, features) matrix
M = noisy.reshape(noisy.shape[0],-1)

# Singular value decomposition factorizes your data matrix such that:
#   M = U*S*V.T     (where '*' is matrix multiplication)
# * U and V are the singular matrices containing orthogonal vectors of unit length
# * S is a diagonal matrix containing the singular values of M - we can use this to calculate our PCs

# Obtain the results of SVD from our noisy matrix
U, s, Vt = np.linalg.svd(M, full_matrices=False)
# Transpose V to get our PC vectors
V = Vt.T

# PCs are already sorted by descending order of the singular values (i.e. by the proportion of total variance they explain)
# If we use all of the PCs we can reconstruct the noisy signal perfectly
S = np.diag(s)
Mhat = np.dot(U, np.dot(S, V.T))
print(“Using all PCs, MSE = %.6G" %(np.mean((M - Mhat)**2)))

14. Làm sao tối ưu hóa việc sử dụng bộ nhớ khi làm việc với các mảng lớn trong NumPy?

Một chức năng ít được sử dụng của NumPy là memmap(). Điều này cho phép chúng ta lưu mảng thành tệp, nhờ đó có thể đọc các mảng lớn hơn so với khi chỉ lưu trong bộ nhớ. Lợi ích chính là đọc dữ liệu lười (lazy), giúp giảm nhu cầu bộ nhớ tổng thể trong khi vẫn có thể đánh giá toàn bộ tập dữ liệu. 

Sử dụng khéo léo hàm này sẽ giúp nhà khoa học dữ liệu làm việc với dữ liệu lớn dễ dàng và thuận tiện hơn.

​​import numpy as np

# Create a large array and save it to a file using memmap
filename = 'large_array.dat'
large_array_shape = (10000, 10000)
dtype = np.float32  # Specify the data type of the array

# Create a memmap object with the desired shape and dtype
large_array = np.memmap(filename, dtype=dtype, mode='w+', shape=large_array_shape)

# Initialize the array with some values (e.g., fill it with random numbers)
large_array[:] = np.random.rand(*large_array_shape)

# Access a small part of the array without loading the entire array into memory
sub_array = large_array[5000:5010, 5000:5010]
print(sub_array)  # Output: A 10x10 array with random float values

# Clean up and ensure that the changes are written to disk
del large_array

15. Làm sao xử lý và thao tác với các mảng có giá trị thiếu hoặc vô hạn trong NumPy?

Xử lý giá trị thiếu và vô hạn là chuyện thường gặp với nhà khoa học dữ liệu. Trước hết, bạn có thể dùng isnan() hoặc isinf() của NumPy để tìm các giá trị thiếu và vô hạn này. 

Nếu có vấn đề có tính hệ thống, chúng ta có thể muốn đánh giá lại các pipeline; nếu không, chúng ta có thể muốn điền các giá trị này. 

Dù có thể không dùng NumPy trực tiếp để điền giá trị thiếu, chúng ta thường dùng các hàm NumPy kết hợp với thứ như pandas fillna() để điền dữ liệu thiếu. Chẳng hạn, chúng ta có thể dùng hàm mean() hoặc median() của NumPy để nhanh chóng lấp các giá trị lỗi.

Câu hỏi phỏng vấn NumPy cho nhà khoa học dữ liệu

Đến đây, chúng ta đã đề cập các câu hỏi NumPy tổng quát. Tất nhiên, những câu hỏi trước có thể áp dụng cho khoa học dữ liệu, nhưng trong phần này, tôi tổng hợp các câu hỏi NumPy cụ thể cho nhà khoa học dữ liệu.

16. Có cách nào nhanh và dễ để áp dụng hàm cho từng hàng và cột của mảng 2D không?

Đôi khi, chúng ta cần thực hiện các phép tính tùy chỉnh trên mảng để lấy thông tin cho từng hàng hoặc cột. May mắn là phương thức apply_along_axis() của NumPy có thể được dùng để áp dụng một hàm tùy chỉnh trên mảng NumPy. Các hàm này được áp dụng trên toàn bộ một trục cụ thể trong mỗi mảng. 

import numpy as np

# Create a 2D array
data = np.array([
    [1, 2, 3, 4, 5],
    [10, 15, 20, 25, 30],
    [100, 200, 300, 400, 500]
])

# Define a function to compute the range of a 1D array
def compute_range(arr):
    return np.max(arr) - np.min(arr)

# Apply the compute_range function to each row (axis=1)
ranges = np.apply_along_axis(compute_range, axis=1, arr=data)
print("Range of each row:", ranges)
# Output:
# Range of each row: [  4  20 400]

17. Làm sao tận dụng NumPy để chuẩn hóa và scale đặc trưng của tập dữ liệu cho machine learning?

Chuẩn hóa dữ liệu đảm bảo chúng ta huấn luyện mô hình machine learning đúng cách. Không có chuẩn hóa, thang đo có thể ảnh hưởng đến kết quả mô hình, đặc biệt với các mô hình dựa trên khoảng cách. 

Chúng ta có thể dùng các hàm của NumPy để thực hiện scaling dễ dàng. Đây là ví dụ về min-max scaling chạy theo tất cả các hàng. Hãy đảm bảo bạn chọn đúng chiều khi scale đặc trưng.

import numpy as np

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

# Min-Max Scaling
min_vals = np.min(data, axis=0)
max_vals = np.max(data, axis=0)
scaled_data = (data - min_vals) / (max_vals - min_vals)
print("Scaled Data:\n", scaled_data)
# Output:
# Scaled Data:
# [[0.   0.   0.  ]
#  [0.5  0.5  0.5 ]
#  [1.   1.   1.  ]]

18. Có những cách nào để chúng ta dễ dàng sắp xếp và lập chỉ mục các mảng NumPy?

Dù chúng ta có thứ như sort_values() của DataFrame, vẫn có những trường hợp ta muốn tìm vị trí của các giá trị đã sắp xếp. 

Hàm argsort() của NumPy cung cấp các vị trí sẽ sắp xếp một mảng cho trước. Một kịch bản hữu ích là khi chúng ta cần lập chỉ mục đúng cho các tập dữ liệu khác để khớp với các mảng đã sắp xếp. Bằng cách có sẵn các vị trí, chúng ta có thể dùng đầu ra từ argsort() để đảm bảo tính nhất quán giữa các tập dữ liệu.

19. Một khía cạnh quan trọng của bộ sinh số ngẫu nhiên của NumPy có thể được dùng để khiến nó dự đoán được là gì và vì sao?

Bộ sinh số ngẫu nhiên trong máy tính không thực sự ngẫu nhiên. Chúng dựa trên một seed ban đầu. Vì chúng ta thường muốn kiểm thử dữ liệu và có thể dễ dàng đánh giá kết quả, chúng ta phải giảm thiểu mức độ ngẫu nhiên trong pipeline. 

Bằng cách dùng phương thức random.seed() của NumPy, chúng ta có thể đặt seed cho toàn bộ pipeline để có kết quả tương tự mỗi lần. Đặt một seed cụ thể cho phép chúng ta đánh giá liệu cải thiện kết quả dựa trên điều chỉnh mô hình hay do ngẫu nhiên.

20. Mô tả cách bạn có thể triển khai K-Means trong NumPy.

Trong buổi phỏng vấn, bạn có thể được yêu cầu triển khai một thuật toán nào đó. Trọng tâm của những câu hỏi này là trả lời với sự hiểu biết nền tảng về mô hình và gói thư viện. 

Bạn không cần phải học thuộc từng dòng mã dưới đây, nhưng hãy có khả năng chỉ ra các bước và phương thức chính cần thiết. Hãy đảm bảo bạn đã đọc về K-Means (và các thuật toán cơ bản khác) và cũng hiểu cách thuật toán hoạt động.

import numpy as np

# Generate a sample dataset
np.random.seed(42)  # For reproducibility
data = np.vstack([
    np.random.normal(loc=[1, 1], scale=0.5, size=(50, 2)),
    np.random.normal(loc=[5, 5], scale=0.5, size=(50, 2)),
    np.random.normal(loc=[9, 1], scale=0.5, size=(50, 2))
])
def k_means(X, k, max_iters=100, tol=1e-4):
    # Step 1: Initialize centroids randomly
    num_samples, num_features = X.shape
    centroids = X[np.random.choice(num_samples, k, replace=False)]
    
    for i in range(max_iters):
        # Step 2: Assign clusters
        distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
        cluster_assignments = np.argmin(distances, axis=1)
        
        # Step 3: Update centroids
        new_centroids = np.array([X[cluster_assignments == j].mean(axis=0) for j in range(k)])
        
        # Check for convergence
        if np.all(np.linalg.norm(new_centroids - centroids, axis=1) < tol):
            break
        
        centroids = new_centroids
    
    return centroids, cluster_assignments

# Apply k-means clustering
k = 3
centroids, cluster_assignments = k_means(data, k)

Lời kết

Bồi đắp kiến thức phỏng vấn với NumPy là một trong những bước quan trọng để thành công trong sự nghiệp khoa học dữ liệu. 

Hãy bắt đầu bằng việc luyện tập và hiểu các nền tảng rồi đến triển khai cụ thể. Bạn dùng Numpy càng nhiều, bạn sẽ càng hiểu và ghi nhớ các hàm của nó tốt hơn. Hãy thử một số khóa học và hướng dẫn trên DataCamp, chẳng hạn như sau:

• Hướng dẫn về mảng Python Numpy
• Cheat Sheet Numpy
• Khóa học cấp tốc Numpy