20 คำถามสัมภาษณ์ NumPy ยอดนิยม: ตั้งแต่พื้นฐานถึงขั้นสูง

คำถามสัมภาษณ์ NumPy ระดับกลาง

คำถามเหล่านี้ลงลึกสู่การใช้งาน NumPy จริง เมื่อมีความเข้าใจพื้นฐานเกี่ยวกับอาร์เรย์ของ NumPy แล้ว ควรสำรวจฟังก์ชันการทำงานของมัน การคำนวณด้วย NumPy ถือว่าเป็นทักษะที่คาดหวังในระดับกลาง

6. จะสร้างอาร์เรย์ที่เป็นศูนย์ทั้งหมดหรือหนึ่งทั้งหมดได้อย่างไร?

การสร้างอาร์เรย์ที่เต็มด้วยศูนย์หรือหนึ่งเป็นความต้องการที่พบบ่อยในงานวิทยาศาสตร์ข้อมูลหลายอย่าง เช่น การตั้งค่าเมทริกซ์เริ่มต้น การสร้างมาสก์อาร์เรย์ หรือการเตรียมโครงสร้างข้อมูลชั่วคราว

เพื่อสร้างอาร์เรย์ที่เป็นศูนย์ทั้งหมดหรือหนึ่งทั้งหมดใน NumPy ให้ใช้ฟังก์ชัน np.zeros() หรือ 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 ใน NumPy คืออะไร?

Broadcasting เป็นพฤติกรรมสำคัญของ NumPy ที่ช่วยให้ดำเนินการอย่างมีประสิทธิภาพบนอาร์เรย์ที่มีขนาดต่างกัน

พูดง่าย ๆ คือช่วยให้อาร์เรย์ต่างขนาดทำเลขคณิตร่วมกันได้โดยทำให้รูปร่างเข้ากันได้ NumPy จะทำซ้ำอาร์เรย์ที่เล็กกว่าบนมิติของอาร์เรย์ที่ใหญ่กว่าโดยอัตโนมัติ เพื่อให้มีรูปร่างที่เข้ากัน

ดูตัวอย่างต่อไปนี้:

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. จะหาค่าเฉลี่ย มัธยฐาน และส่วนเบี่ยงเบนมาตรฐานของอาร์เรย์ NumPy ได้อย่างไร?

ค่าเฉลี่ย มัธยฐาน และส่วนเบี่ยงเบนมาตรฐานเป็นสถิติเชิงพรรณนาที่สำคัญซึ่งใช้ทำความเข้าใจกับข้อมูลของเรา NumPy คำนวณค่าเหล่านี้ได้ง่ายมากและมีฟังก์ชันเฉพาะรองรับ

การรู้วิธีคำนวณเหล่านี้ช่วยเสริมความสามารถในการใช้ NumPy:

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. จะใช้ NumPy ในการคิวรีข้อมูลตัวเลขอย่างรวดเร็วและดำเนินการตามเงื่อนไขบูลีนได้อย่างไร?

แม้เราจะมองว่า NumPy มีหน้าที่หลักด้านการคำนวณ แต่ก็มีความสามารถในการจัดการข้อมูลที่ทรงพลังด้วย

NumPy สามารถคิวรีข้อมูลได้ง่ายผ่านการทำดัชนีแบบบูลีน และดำเนินการตามผลลัพธ์ เมธอด where() มีประโยชน์มากเมื่ออยากเปลี่ยนแปลงข้อมูลตามค่าตัวเลข

สมมติว่ามีดาต้าเฟรมคะแนนสอบชื่อ df และต้องการจัดกลุ่มนักเรียน np.where() แบบง่ายอาจเป็นดังนี้:

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

สังเกตว่าเมธอด where() รับอินพุตได้สูงสุด 3 ค่า:

• ค่าที่หนึ่งคือเงื่อนไขบูลีนใด ๆ
• ค่าที่สองคือผลลัพธ์เมื่อเป็นจริง
• ค่าที่สามคือผลลัพธ์เมื่อเป็นเท็จ

10. จะใช้ NumPy ทำสิ่งอย่างเช่น Mean Squared Error ได้อย่างไร?

ความสามารถของ NumPy ในการทำงานทั้งอาร์เรย์พร้อมกันทำให้การคำนวณอย่าง Mean Squared Error (MSE) ทำได้ง่าย

เพราะดำเนินการง่าย ๆ แบบองค์ประกอบต่อองค์ประกอบ จึงเวกเตอร์ไรซ์การคำนวณได้ง่ายและมีประสิทธิภาพในการคำนวณ MSE

ตัวอย่างการทำ MSE ใน NumPy มีดังนี้:

# 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))

คำถามสัมภาษณ์ NumPy ระดับสูง

ถึงเวลาสู่ระดับขั้นสูง คาดหวังให้ใช้ NumPy แก้ปัญหาที่ซับซ้อนมากขึ้นในระดับนี้

11. จะคำนวณสถิติแบบเลื่อนหน้าต่าง (rolling) ด้วย NumPy เช่น ค่าเฉลี่ยเคลื่อนที่ ได้อย่างไร?

สถิติแบบเลื่อนหน้าต่าง เช่น ค่าเฉลี่ยเคลื่อนที่ สำคัญมากในวิทยาศาสตร์ข้อมูล มักใช้เพื่อทำให้ข้อมูลที่มีสัญญาณรบกวนเรียบขึ้น โดยเฉพาะข้อมูลอนุกรมเวลา

ฟังก์ชันหนึ่งที่ไม่ค่อยมีใครรู้ของ NumPy คือ “stride” วิธีหนึ่งในการใช้งาน stride คือการสร้างมุมมองแบบหน้าต่างเลื่อนไปบนอาร์เรย์ของคุณ ด้วย lib.stride_tricks.sliding_window_view() สามารถสร้างชุดย่อยของอาร์เรย์ได้ง่าย

จากนั้นสามารถทำสรุปใด ๆ เช่นคำนวณค่าเฉลี่ย บนชุดย่อยแต่ละชุดเพื่อให้ได้ค่าเฉลี่ยเคลื่อนที่ ตัวอย่างการใช้งาน:

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. จะทำดัชนีขั้นสูงเพื่อเลือกองค์ประกอบจากอาร์เรย์หลายมิติตามเงื่อนไขได้อย่างไร?

แม้การทำดัชนีจะเป็นทักษะพื้นฐานของ NumPy แต่การใช้เทคนิคการทำดัชนีขั้นสูงจะช่วยให้นักวิทยาศาสตร์ข้อมูลตัดชิ้นข้อมูลได้แม่นยำยิ่งขึ้น

ด้วยการใช้การทำดัชนีด้วยอาร์เรย์จำนวนเต็มและบูลีน การสร้างชุดข้อมูลที่ตรงตามเกณฑ์เฉพาะจะเป็นเรื่องง่าย

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. จะใช้ NumPy ทำพีชคณิตเชิงเส้น เช่น การแยกตัวประกอบเมทริกซ์ หรือแก้ระบบสมการเชิงเส้น ได้อย่างไร?

การทำการแยกตัวประกอบของเมทริกซ์สำคัญมากสำหรับนักวิทยาศาสตร์ข้อมูลที่ต้องจัดการข้อมูลจำนวนมาก การลดข้อมูลให้เหลือ องค์ประกอบหลัก เป็นก้าวแรกที่สำคัญในการลดความซับซ้อนและสัญญาณรบกวน

โมดูล linalg ของ NumPy ช่วยให้ทำพีชคณิตเชิงเส้นเพื่อหาองค์ประกอบหลักได้ง่าย

# 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. จะเพิ่มประสิทธิภาพการใช้หน่วยความจำเมื่อทำงานกับอาร์เรย์ขนาดใหญ่ใน NumPy ได้อย่างไร?

ฟังก์ชันหนึ่งของ NumPy ที่ไม่ค่อยใช้กันคือ memmap() ซึ่งช่วยเก็บอาร์เรย์เป็นไฟล์ ทำให้สามารถอ่านอาร์เรย์ที่ใหญ่กว่าหน่วยความจำได้ ประโยชน์หลักคือการอ่านข้อมูลแบบขี้เกียจ (lazy) ซึ่งลดความต้องการหน่วยความจำโดยรวม แต่ยังประเมินทั้งชุดข้อมูลได้

การใช้ฟังก์ชันนี้อย่างชาญฉลาดช่วยให้นักวิทยาศาสตร์ข้อมูลทำงานกับข้อมูลขนาดใหญ่ได้ง่ายและสะดวกขึ้น

​​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. จะจัดการและปรับแต่งอาร์เรย์ที่มีค่าว่างหรือค่าอนันต์ใน NumPy ได้อย่างไร?

การจัดการค่าว่างและค่าอนันต์เป็นเรื่องปกติสำหรับนักวิทยาศาสตร์ข้อมูล ขั้นแรกอาจใช้ isnan() หรือ isinf() ของ NumPy เพื่อค้นหาค่าเหล่านี้

หากมีปัญหาเชิงระบบ อาจต้องประเมินไปป์ไลน์ของเรา มิฉะนั้นอาจต้องเติมค่าเหล่านี้

แม้อาจไม่ใช้ NumPy โดยตรงในการเติมค่าว่าง แต่บ่อยครั้งจะใช้ฟังก์ชันของ NumPy ร่วมกับ fillna() ของ pandas เพื่อเติมข้อมูลที่หายไป ตัวอย่างเช่น อาจใช้ฟังก์ชัน mean() หรือ median() ของ NumPy เพื่อเติมค่าที่ผิดพลาดได้อย่างรวดเร็ว

คำถามสัมภาษณ์ NumPy สำหรับนักวิทยาศาสตร์ข้อมูล

จนถึงตอนนี้เราได้ครอบคลุมคำถามทั่วไปของ NumPy แน่นอนว่าคำถามก่อนหน้านี้อาจใช้กับวิทยาศาสตร์ข้อมูลด้วย แต่ในส่วนนี้ได้รวบรวมคำถาม NumPy เฉพาะสำหรับนักวิทยาศาสตร์ข้อมูล

16. มีวิธีที่รวดเร็วและง่ายในการใช้ฟังก์ชันกับแต่ละแถวและคอลัมน์ของอาร์เรย์ 2 มิติหรือไม่?

บางครั้งต้องทำการคำนวณแบบกำหนดเองบนอาร์เรย์เพื่อดูข้อมูลของแต่ละแถวหรือคอลัมน์ โชคดีที่เมธอด apply_along_axis() ของ NumPy ใช้สำหรับประยุกต์ฟังก์ชันกำหนดเองกับอาร์เรย์ NumPy ได้ ฟังก์ชันจะถูกประยุกต์บนแกนที่ระบุของแต่ละอาร์เรย์ทั้งหมด

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. จะใช้ NumPy เพื่อทำการสเกลฟีเจอร์และทำ normalization ของชุดข้อมูลสำหรับแมชชีนเลิร์นนิงได้อย่างไร?

การทำ normalization ของข้อมูลช่วยให้ฝึกโมเดลแมชชีนเลิร์นนิงได้อย่างถูกต้อง หากไม่ทำ normalization สเกลของตัวแปรอาจกระทบผลลัพธ์ของโมเดล โดยเฉพาะโมเดลที่อาศัยระยะทาง

สามารถใช้ฟังก์ชันของ NumPy เพื่อทำการสเกลได้ง่าย ตัวอย่างต่อไปนี้คือการสเกลแบบมิน-แมกซ์ที่คำนวณตามทุกแถว ตรวจสอบให้แน่ใจว่าเลือกมิติถูกต้องเมื่อทำการสเกลฟีเจอร์

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. มีวิธีใดบ้างที่สามารถจัดเรียงและทำดัชนีอาร์เรย์ของ NumPy ได้อย่างง่ายดาย?

แม้จะมีฟังก์ชันอย่าง sort_values() ใน DataFrame แต่บางกรณีเราต้องการหาตำแหน่งของค่าหลังการจัดเรียง

ฟังก์ชัน argsort() ของ NumPy ให้ตำแหน่งที่จะจัดเรียงอาร์เรย์ที่กำหนด สถานการณ์หนึ่งที่มีประโยชน์คือเมื่อเราต้องทำดัชนีชุดข้อมูลอื่นให้ตรงกับอาร์เรย์ที่จัดเรียงไว้ ด้วยการมีตำแหน่งพร้อม เราจึงใช้ผลลัพธ์จาก argsort() เพื่อให้เกิดความสอดคล้องระหว่างชุดข้อมูลต่าง ๆ

19. องค์ประกอบสำคัญอย่างหนึ่งของตัวสร้างตัวเลขสุ่มของ NumPy ที่ใช้ทำให้คาดเดาได้คืออะไร และทำไม?

ตัวสร้างตัวเลขสุ่มในคอมพิวติ้งไม่ได้สุ่มแท้ ๆ แต่ขึ้นกับค่า seed เริ่มต้น เนื่องจากมักต้องทดสอบข้อมูลและประเมินผลได้ง่าย จึงต้องลดความสุ่มในไปป์ไลน์ให้เหลือน้อยที่สุด

ด้วยการใช้เมธอด random.seed() ของ NumPy เราตั้งค่า seed ให้ทั้งไปป์ไลน์เพื่อให้ได้ผลลัพธ์คล้ายกันทุกครั้ง การตั้งค่า seed เฉพาะช่วยให้ประเมินได้ว่าการปรับปรุงผลลัพธ์มาจากการปรับโมเดล ไม่ใช่ความสุ่ม

20. อธิบายวิธีที่อาจใช้ NumPy เพื่อนำ K-Means ไปใช้งาน

ระหว่างการสัมภาษณ์ อาจถูกขอให้ลงมือเขียนอัลกอริทึมบางอย่าง จุดสำคัญของคำถามเหล่านี้คือการตอบด้วยความเข้าใจพื้นฐานของโมเดลและแพ็กเกจ

ไม่จำเป็นต้องท่องจำโค้ดทุกบรรทัดด้านล่าง แต่ควรชี้ขั้นตอนหลักและเมธอดที่ต้องใช้ให้ได้ ตรวจสอบให้แน่ใจว่าได้อ่านเกี่ยวกับ K-Means (และอัลกอริทึมพื้นฐานอื่น ๆ) และเข้าใจวิธีการทำงานของอัลกอริทึมด้วย

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)

ข้อคิดส่งท้าย

การเพิ่มพูนความรู้สำหรับการสัมภาษณ์ด้วย NumPy เป็นหนึ่งในกุญแจสำคัญสู่ความสำเร็จใน สายงานวิทยาศาสตร์ข้อมูล

เริ่มจากการฝึกและทำความเข้าใจ พื้นฐาน แล้วต่อด้วยการลงมือใช้งานเฉพาะทาง ยิ่งใช้ Numpy บ่อยเท่าไร ก็จะยิ่งเข้าใจและซึมซับฟังก์ชันของมันมากขึ้น ลองคอร์สและบทเรียนบน DataCamp เช่นต่อไปนี้:

• Python Numpy Array Tutorial
• Numpy Cheat Sheet
• Numpy Crash Course