20 Pertanyaan Wawancara NumPy Teratas: Dari Dasar hingga Lanjutan

Pertanyaan Wawancara NumPy Tingkat Menengah

Pertanyaan-pertanyaan ini menggali lebih dalam penggunaan NumPy secara nyata. Setelah Anda memahami dasar-dasar array NumPy, jelajahi fungsionalitasnya. Melakukan perhitungan dengan NumPy dapat diharapkan pada tingkat menengah.

6. Bagaimana cara membuat array berisi semua nol atau semua satu?

Membuat array yang diisi nol atau satu adalah kebutuhan umum dalam banyak tugas data science, seperti menginisialisasi matriks, membuat array mask, atau menyiapkan struktur data placeholder. 

Untuk membuat array berisi semua nol atau semua satu di NumPy, gunakan fungsi np.zeros() atau np.ones():

import numpy as np

# Membuat array 3x4 berisi nol
zeros_arr = np.zeros((3, 4))
print(zeros_arr)
# Output:
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

# Membuat array 2x2 berisi satu
ones_arr = np.ones((2, 2))
print(ones_arr)
# Output:
# [[1. 1.]
#  [1. 1.]]

7. Apa itu broadcasting dalam NumPy?

Broadcasting adalah perilaku kunci NumPy yang memungkinkan operasi efisien pada array dengan ukuran berbeda. 

Sederhananya, ini memungkinkan operasi aritmetika antara array berukuran berbeda dengan memastikan kedua array memiliki shape yang kompatibel. Ini dilakukan saat NumPy secara otomatis mereplikasi array yang lebih kecil ke seluruh array yang lebih besar agar shape-nya kompatibel. 

Lihat contoh berikut:

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. Bagaimana cara menemukan mean, median, dan standar deviasi dari array NumPy?

Mean, median, dan standar deviasi adalah statistik deskriptif kunci yang umum digunakan untuk memahami data kita. NumPy menghitungnya dengan sangat mudah dan memiliki fungsi khusus untuk itu. 

Mengetahui perhitungan ini penting untuk meningkatkan kemampuan kita memanfaatkan 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

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

9. Bagaimana kita dapat memanfaatkan NumPy untuk dengan cepat melakukan query pada data numerik dan melakukan aksi berdasarkan pernyataan boolean?

Walau kita menganggap tujuan utama NumPy sebagai paket perhitungan, ia juga memiliki kemampuan pengolahan data yang kuat. 

NumPy dapat dengan mudah melakukan query data melalui boolean indexing dan melakukan operasi berdasarkan hasilnya. Metode where() sangat berguna saat kita ingin membuat perubahan pada data berdasarkan nilai numerik.

Misalkan kita memiliki data frame nilai ujian bernama df dan ingin mengategorikan siswa. Contoh sederhana np.where() dapat terlihat seperti:

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

Perhatikan bahwa metode where() menerima hingga 3 masukan: 

• Pertama adalah pernyataan boolean jenis apa pun
• Kedua adalah hasil jika benar
• Ketiga adalah hasil jika salah

10. Apa cara untuk memanfaatkan NumPy guna menghitung Mean Squared Error?

Kemampuan NumPy untuk bekerja pada seluruh array sekaligus membuat implementasi perhitungan seperti Mean Squared Error (MSE) menjadi sederhana. 

Karena menjalankan operasi sederhana secara elemen per elemen, NumPy dengan mudah memvektorisasi operasi tersebut dan menyediakan cara efisien untuk menghitung MSE. 

Contoh implementasi MSE di NumPy sebagai berikut:

# 1. Kita memiliki dua array, prediksi dan label aktual
# 2. Kita ambil selisih kuadratnya lalu jumlahkan
# 3. Lalu bagi dengan n, yaitu panjang array

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

Pertanyaan Wawancara NumPy Tingkat Lanjutan

Sekarang saatnya memasuki ranah lanjutan! Pada level ini, Anda diharapkan menggunakan NumPy untuk menyelesaikan masalah yang lebih kompleks.

11. Bagaimana Anda dapat menghitung statistik rolling menggunakan NumPy, seperti rolling mean?

Statistik rolling seperti rata-rata bergulir sangat penting dalam data science. Rolling mean sering digunakan untuk menghaluskan data yang bising, terutama jika berbasis waktu. 

Fungsionalitas NumPy yang jarang diketahui adalah “stride.” Salah satu cara implementasinya adalah membuat tampilan jendela geser dari array Anda. Dengan menggunakan lib.stride_tricks.sliding_window_view(), Anda dapat dengan mudah menghasilkan subset array. 

Kemudian Anda dapat melakukan ringkasan apa pun, seperti menghitung mean, pada masing-masing subset ini untuk memperoleh rata-rata bergulir. Berikut contoh implementasinya:

import numpy as np

from numpy.lib.stride_tricks import sliding_window_view
x = np.arange(6)
v = sliding_window_view(x, 3)
# Ini membuat v, sebuah array yang berisi subarray berdimensi 3 yang mencerminkan ukuran jendela.

12. Bagaimana Anda melakukan advanced indexing untuk memilih elemen dari array multi-dimensi berdasarkan suatu kondisi?

Meskipun indexing adalah keterampilan fundamental untuk NumPy, memanfaatkan teknik indexing yang lebih lanjut memungkinkan data scientist melakukan slicing data dengan lebih presisi. 

Dengan memanfaatkan integer array indexing dan boolean indexing, membuat dataset yang memenuhi kriteria spesifik menjadi hal yang sepele.

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: Pilih elemen yang lebih besar dari 30
condition = array > 30
print(condition)  # Output:
# [[False False False False]
#  [False  True  True  True]
#  [ True  True  True  True]]

# Terapkan kondisi untuk mendapatkan elemen yang memenuhi kriteria
filtered_elements = array[condition]
print(filtered_elements)  # Output: [35 40 45 50 55 60 65]

# Integer array indexing: Pilih elemen spesifik berdasarkan indeks baris dan kolom
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]

# Mengombinasikan boolean dan integer indexing
# Pilih elemen dari array di mana elemennya lebih besar dari 30 dan berasal dari indeks tertentu
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. Bagaimana Anda menggunakan NumPy untuk melakukan operasi aljabar linear seperti dekomposisi matriks atau menyelesaikan sistem persamaan linear?

Melakukan dekomposisi matriks sangat penting bagi data scientist yang menangani volume data besar. Mereduksi data ke komponen utama merupakan langkah awal yang krusial untuk mengurangi kompleksitas dan noise. 

Modul linalg milik NumPy memungkinkan kita dengan mudah melakukan aljabar linear untuk memperoleh komponen utama. 

# Sinyal dasar adalah citra yang dimodulasi secara sinusoidal
img = lena() # Ini dari scipy.misc import lena
t = np.arange(100)
time = np.sin(0.1*t)
true= time[:,np.newaxis,np.newaxis] * img[np.newaxis,...]

# Kita tambahkan sedikit noise
noisy = real + np.random.randn(*true.shape)*255

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

# Dekomposisi nilai singular memfaktorkan matriks data Anda sehingga:
#   M = U*S*V.T     (di mana '*' adalah perkalian matriks)
# * U dan V adalah matriks singular yang berisi vektor ortogonal berdimensi satuan
# * S adalah matriks diagonal yang berisi nilai singular M - kita dapat menggunakannya untuk menghitung PC

# Peroleh hasil SVD dari matriks noisy kita
U, s, Vt = np.linalg.svd(M, full_matrices=False)
# Transpos V untuk mendapatkan vektor PC
V = Vt.T

# PC sudah diurutkan berdasarkan urutan menurun dari nilai singular (yakni berdasarkan proporsi total varians yang dijelaskan)
# Jika kita menggunakan semua PC, kita dapat merekonstruksi sinyal noisy dengan sempurna
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. Bagaimana Anda dapat mengoptimalkan penggunaan memori saat bekerja dengan array besar di NumPy?

Fungsionalitas NumPy yang jarang digunakan adalah memmap(). Ini memungkinkan kita menyimpan array sebagai berkas, sehingga memungkinkan pembacaan array yang lebih besar daripada yang bisa ditampung murni di memori. Manfaat utamanya adalah pembacaan data secara malas (lazy), yang mengurangi kebutuhan memori keseluruhan sambil tetap memungkinkan kita menilai seluruh dataset. 

Penggunaan yang cermat terhadap fungsi ini akan memudahkan dan mempermudah data scientist bekerja dengan data besar.

​​import numpy as np

# Buat array besar dan simpan ke berkas menggunakan memmap
filename = 'large_array.dat'
large_array_shape = (10000, 10000)
dtype = np.float32  # Tentukan tipe data array

# Buat objek memmap dengan shape dan dtype yang diinginkan
large_array = np.memmap(filename, dtype=dtype, mode='w+', shape=large_array_shape)

# Inisialisasi array dengan beberapa nilai (misalnya, isi dengan angka acak)
large_array[:] = np.random.rand(*large_array_shape)

# Akses sebagian kecil dari array tanpa memuat seluruh array ke memori
sub_array = large_array[5000:5010, 5000:5010]
print(sub_array)  # Output: Array 10x10 dengan nilai float acak

# Bersihkan dan pastikan perubahan ditulis ke disk
del large_array

15. Bagaimana Anda menangani dan memanipulasi array dengan nilai hilang atau tak hingga di NumPy?

Menangani nilai hilang dan tak hingga adalah hal umum bagi data scientist. Pertama, Anda mungkin ingin menggunakan isnan() atau isinf() milik NumPy untuk menemukan nilai hilang dan tak hingga tersebut. 

Jika ada masalah sistematis, kita mungkin ingin menilai pipeline kita; jika tidak, kita dapat mengisi nilai-nilai tersebut. 

Meskipun kita mungkin tidak menggunakan NumPy secara langsung untuk mengisi nilai hilang, kita sering menggunakan fungsi NumPy dikombinasikan dengan sesuatu seperti fillna() pada pandas untuk mengisi data yang hilang. Misalnya, kita mungkin ingin menggunakan fungsi mean() atau median() milik NumPy untuk dengan cepat mengisi nilai yang keliru.

Pertanyaan Wawancara NumPy untuk Data Scientist

Hingga kini, kita telah membahas pertanyaan umum NumPy. Tentu, pertanyaan-pertanyaan sebelumnya mungkin berlaku untuk data science, tetapi di bagian ini, saya mengumpulkan pertanyaan NumPy spesifik untuk data scientist.

16. Adakah cara cepat dan mudah menerapkan fungsi ke setiap baris dan kolom dari array 2D?

Terkadang, kita perlu melakukan perhitungan kustom pada array untuk mendapatkan informasi pada setiap baris atau kolom. Syukurlah, metode NumPy apply_along_axis() dapat digunakan untuk menerapkan fungsi kustom ke seluruh array NumPy. Fungsi-fungsi ini diterapkan pada keseluruhan suatu sumbu tertentu di setiap array. 

import numpy as np

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

# Definisikan fungsi untuk menghitung rentang pada array 1D
def compute_range(arr):
    return np.max(arr) - np.min(arr)

# Terapkan fungsi compute_range ke setiap baris (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. Bagaimana Anda memanfaatkan NumPy untuk melakukan feature scaling dan normalisasi dataset untuk machine learning?

Normalisasi data memastikan kita melatih model machine learning dengan benar. Tanpa normalisasi, skala dapat memengaruhi hasil model, terutama untuk model berbasis jarak. 

Kita dapat menggunakan fungsi NumPy untuk dengan mudah melakukan scaling. Berikut contoh min-max scaling yang dijalankan untuk semua baris. Pastikan Anda memilih dimensi yang tepat saat melakukan feature scaling.

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. Apa saja cara mudah untuk mengurutkan dan mengindeks array NumPy kita?

Meskipun kita memiliki sesuatu seperti sort_values() pada DataFrame, ada kasus tertentu saat kita ingin menemukan lokasi dari nilai-nilai yang telah diurutkan tersebut. 

Fungsi argsort() milik NumPy menyediakan posisi yang akan mengurutkan sebuah array. Salah satu skenario berguna adalah ketika kita perlu mengindeks dataset lain agar sesuai dengan array yang telah diurutkan. Dengan memiliki posisi-posisi tersebut, kita dapat memanfaatkan keluaran dari argsort() untuk memastikan konsistensi di seluruh dataset.

19. Apa satu aspek penting dari generator angka acak NumPy yang dapat dimanfaatkan agar dapat diprediksi dan mengapa?

Generator angka acak dalam komputasi tidak benar-benar acak. Mereka didasarkan pada seed awal. Karena kita sering ingin menguji data dan dapat dengan mudah menilai hasil, kita harus meminimalkan tingkat keacakan dalam pipeline kita. 

Dengan memanfaatkan metode random.seed() milik NumPy, kita dapat menetapkan seed untuk seluruh pipeline sehingga kita memperoleh hasil yang serupa setiap kali. Menetapkan seed tertentu memungkinkan kita menilai apakah peningkatan hasil didasarkan pada penyesuaian model kita, bukan karena keacakan.

20. Jelaskan bagaimana Anda mungkin mengimplementasikan K-Means di NumPy.

Dalam wawancara, Anda mungkin diminta mengimplementasikan sebuah algoritma. Fokus dari pertanyaan-pertanyaan ini adalah menjawab dengan pemahaman fundamental tentang model dan paketnya. 

Anda tidak perlu menghafal setiap baris kode di bawah ini, namun mampu menunjukkan langkah kunci dan metode yang dibutuhkan. Pastikan Anda telah membaca tentang K-Means (dan algoritme dasar lainnya) serta memahami cara kerja algoritmenya.

import numpy as np

# Hasilkan dataset contoh
np.random.seed(42)  # Untuk reprodusibilitas
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):
    # Langkah 1: Inisialisasi centroid secara acak
    num_samples, num_features = X.shape
    centroids = X[np.random.choice(num_samples, k, replace=False)]
    
    for i in range(max_iters):
        # Langkah 2: Penetapan klaster
        distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
        cluster_assignments = np.argmin(distances, axis=1)
        
        # Langkah 3: Perbarui centroid
        new_centroids = np.array([X[cluster_assignments == j].mean(axis=0) for j in range(k)])
        
        # Periksa konvergensi
        if np.all(np.linalg.norm(new_centroids - centroids, axis=1) < tol):
            break
        
        centroids = new_centroids
    
    return centroids, cluster_assignments

# Terapkan pengelompokan k-means
k = 3
centroids, cluster_assignments = k_means(data, k)

Penutup

Membangun pengetahuan wawancara Anda dengan NumPy adalah salah satu langkah krusial menuju sukses dalam karier di data science. 

Mulailah dengan berlatih dan memahami dasar-dasarnya diikuti dengan implementasi spesifik. Semakin sering Anda menggunakan NumPy, semakin baik Anda akan memahami dan menginternalisasi fungsinya. Coba beberapa kursus dan tutorial di DataCamp, seperti berikut:

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