En İyi 20 NumPy Mülakat Sorusu: Temelden İleri Düzeye

Orta Düzey NumPy Mülakat Soruları

Bu sorular, NumPy’yi fiilen kullanmaya daha derinlemesine girer. NumPy dizilerine ilişkin temel bir anlayış oluşturduktan sonra, işlevselliğini keşfetmelisiniz. Orta düzeyde NumPy ile hesaplamalar yapmanız beklenir.

6. Tamamı sıfır veya tamamı birlerden oluşan bir dizi nasıl oluşturulur?

Sıfırlar veya birlerle doldurulmuş diziler oluşturmak; matrisleri başlatmak, maske dizileri yaratmak veya yer tutucu veri yapıları kurmak gibi birçok veri bilimi görevinde yaygındır. 

NumPy’de tamamı sıfır veya birlerden oluşan bir dizi oluşturmak için np.zeros() veya np.ones() fonksiyonlarını kullanırsınız:

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. NumPy’de yayınlama (broadcasting) nedir?

Broadcasting, farklı boyutlardaki diziler üzerinde verimli işlemler yapılmasını sağlayan temel bir NumPy davranışıdır. 

Kısaca, NumPy’nin daha küçük dizileri daha büyük dizi üzerinde otomatik olarak çoğaltarak şekilleri uyumlu hâle getirmesi sayesinde farklı boyutlardaki diziler arasında aritmetik işlemler yapılmasına olanak tanır. 

Aşağıdaki örneğe bakın:

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. Bir NumPy dizisinin ortalamasını, medyanını ve standart sapmasını nasıl bulursunuz?

Ortalama, medyan ve standart sapma; verimizi anlamak için yaygın olarak kullanılan temel tanımlayıcı istatistiklerdir. NumPy bunları çok kolay hesaplar ve bunlar için özel fonksiyonlara sahiptir. 

Bu hesaplamaları bilmek, NumPy’yi kullanma becerimizi artırmak açısından önemlidir:

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. Sayısal verimizi hızlıca sorgulamak ve bir mantıksal ifadeye göre işlemler yapmak için NumPy’yi nasıl kullanabiliriz?

NumPy’nin birincil amacını hesaplama paketi olarak düşünsek de, güçlü veri düzenleme yeteneklerine de sahiptir. 

NumPy, mantıksal indeksleme ile veriyi kolayca sorgulayabilir ve sonuçlara göre işlemler yapabilir. where() metodu, sayısal değerlere göre verimizde değişiklik yapmak istediğimizde özellikle kullanışlıdır.

Diyelim ki df adlı bir sınav notları veri çerçevemiz var ve öğrencileri kategorize etmek istiyoruz. Basit bir np.where() şöyle görünebilir:

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

Dikkat edin, where() metodu en fazla 3 girdi alır: 

• İlki, herhangi bir türde mantıksal ifadedir
• İkincisi, doğruysa dönecek sonuç
• Üçüncüsü, yanlışsa dönecek sonuç

10. Ortalama Kare Hata (MSE) gibi bir şey için NumPy’yi nasıl kullanabiliriz?

NumPy’nin bir dizinin tamamı üzerinde aynı anda çalışabilmesi, Ortalama Kare Hata (MSE) gibi hesaplamaları uygulamayı kolaylaştırır. 

Basit işlemleri öğe bazında gerçekleştirdiği için işlemi kolayca vektörleştirir ve MSE’yi hesaplamak için verimli bir yol sunar. 

NumPy ile MSE uygulamasına bir örnek aşağıdadır:

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

İleri Düzey NumPy Mülakat Soruları

Şimdi ileri seviyeye geçme zamanı! Bu düzeyde, daha karmaşık problemleri NumPy ile çözmeniz beklenir.

11. NumPy kullanarak hareketli istatistikleri, örneğin hareketli ortalamayı, nasıl hesaplayabilirsiniz?

Hareketli ortalama gibi hareketli istatistikler veri biliminde çok önemlidir. Özellikle zamana dayalı gürültülü veriyi yumuşatmak için sıkça kullanılır. 

NumPy’nin az bilinen işlevlerinden biri de “stride”lardır. Stride’ın uygulama yollarından biri, dizinizin kayan pencereli bir görünümünü oluşturmaktır. lib.stride_tricks.sliding_window_view() kullanarak kolayca alt dizi görünümleri üretebilirsiniz. 

Daha sonra bu alt kümelerin her biri üzerinde, ortalama hesaplamak gibi, herhangi bir özetleme işlemi yaparak hareketli ortalama elde edebilirsiniz. İşte örnek bir uygulama:

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. Çok boyutlu bir diziden bir koşula göre öğeleri seçmek için gelişmiş indekslemeyi nasıl yaparsınız?

İndeksleme NumPy için temel bir beceri olsa da, daha gelişmiş indeksleme tekniklerini kullanmak veri bilimcilerin verilerini daha hassas şekilde dilimlemesine olanak tanır. 

Tamsayı dizi indeksleme ve mantıksal indekslemeden yararlanarak belirli ölçütleri karşılayan veri kümeleri oluşturmak sıradan bir iş hâline gelir.

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’yi kullanarak matris ayrıştırması gibi bir doğrusal cebir işlemi yapabilir veya doğrusal denklem sistemi çözebilir misiniz?

Matris ayrıştırması, büyük veri hacimleriyle uğraşan veri bilimciler için hayati önemdedir. Veriyi temel bileşenlerine indirgemek, karmaşıklığı ve gürültüyü azaltmada kritik ilk adımdır. 

NumPy’nin linalg modülü, temel bileşenleri elde etmek için doğrusal cebiri kolayca gerçekleştirmemize imkân tanır. 

# 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’de büyük dizilerle çalışırken bellek kullanımını nasıl optimize edebilirsiniz?

NumPy’nin nadiren kullanılan işlevlerinden biri memmap()’tir. Bu, dizileri bir dosya olarak saklamamıza olanak tanır; böylece yalnızca bellektekinden daha büyük dizileri okuyabiliriz. Ana faydası, tüm veri kümesini değerlendirmeye imkân verirken toplam bellek ihtiyacını azaltan tembel veri okumasıdır. 

Bu fonksiyonu akıllıca kullanmak, bir veri bilimcisinin büyük verilerle daha kolay ve rahat çalışmasını sağlar.

​​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’de eksik veya sonsuz değerlere sahip dizileri nasıl ele alır ve işlersiniz?

Eksik ve sonsuz değerlerle uğraşmak, veri bilimciler için yaygındır. Öncelikle bu eksik ve sonsuz değerleri bulmak için NumPy’nin isnan() veya isinf() fonksiyonlarını kullanmak isteyebilirsiniz. 

Sistematik bir sorun varsa süreçlerimizi değerlendirmek isteyebiliriz; aksi hâlde bu değerleri doldurmayı düşünebiliriz. 

Eksik değerleri doğrudan NumPy ile doldurmasak da, çoğu zaman pandas’ın fillna() gibi işlevleriyle birlikte NumPy fonksiyonlarını kullanırız. Örneğin, hatalı değerleri hızlıca doldurmak için NumPy’nin mean() veya median() fonksiyonlarını kullanmak isteyebiliriz.

Veri Bilimciler için NumPy Mülakat Soruları

Şimdiye kadar genel NumPy sorularını ele aldık. Elbette önceki sorular veri bilimine de uygulanabilir; ancak bu bölümde, veri bilimciler için özel NumPy sorularını derledim.

16. 2B bir dizinin her satırına ve sütununa hızlı ve kolayca fonksiyon uygulamanın bir yolu var mı?

Bazen, her satır veya sütun hakkında bilgi edinmek için dizimiz üzerinde özel hesaplamalar yapmamız gerekir. Neyse ki NumPy’nin apply_along_axis() metodu, özel bir fonksiyonu bir NumPy dizisi boyunca uygulamak için kullanılabilir. Bu fonksiyonlar, her dizide belirli bir eksenin tamamı boyunca uygulanır. 

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. Makine öğrenimi için veri kümelerinin özellik ölçeklendirmesi ve normalizasyonunu gerçekleştirmek üzere NumPy’den nasıl yararlanabilirsiniz?

Verinin normalizasyonu, makine öğrenimi modellerimizi doğru şekilde eğitmemizi sağlar. Normalizasyon olmadan, özellikle uzaklık tabanlı modellerde, ölçek sonuçlarımızı etkileyebilir. 

NumPy’nin fonksiyonlarını kullanarak ölçeklemeyi kolayca yapabiliriz. Aşağıda tüm satırlar için çalışan min-maks ölçeklemesine bir örnek verilmiştir. Özellik ölçeklemesi yaparken doğru boyutu seçtiğinizden emin olun.

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 dizilerimizi kolayca sıralamak ve indekslemek için hangi yolları kullanabiliriz?

DataFrame’in sort_values() gibi bir işlevi olsa da, bazı durumlarda bu sıralanmış değerlerin konumlarını bulmak isteyebiliriz. 

NumPy’nin argsort() fonksiyonu, verilen bir diziyi sıralayacak konumları sağlar. Faydalı bir senaryo, diğer veri kümelerini sıralanmış dizilerimize uygun şekilde doğru indekslememiz gerektiğinde ortaya çıkar. Konumlar hazır olduğunda, veri kümelerimiz arasında tutarlılık sağlamak için argsort() çıktısından yararlanabiliriz.

19. NumPy’nin rastgele sayı üretecinin öngörülebilir hale getirilmesinde yararlanılabilecek önemli bir yönü nedir ve neden?

Bilgisayarlardaki rastgele sayı üreteçleri gerçekte rastgele değildir. Başlangıçta verilen bir tohuma dayanırlar. Verilerimizi test etmek ve sonuçları kolayca değerlendirmek istediğimiz için, süreçlerimizdeki rastgeleliği en aza indirmeliyiz. 

NumPy’nin random.seed() metodunu kullanarak tüm bir süreç için tohumu ayarlayabilir ve her seferinde benzer sonuçlar elde edebiliriz. Belirli bir tohum belirlemek, sonuçlarımızdaki iyileşmelerin model ayarlamalarımıza mı yoksa rastgeleliğe mi dayandığını değerlendirmemize yardımcı olur.

20. NumPy’de K-Ortalamalar (K-Means) nasıl uygulanır?

Bir mülakatta sizden bir algoritma uygulamanız istenebilir. Bu tür soruların odağı, modelin ve paketin temel mantığını anlayarak yanıt verebilmektir. 

Aşağıdaki kodun her satırını ezberlemeniz gerekmez; ancak gereken temel adımları ve metodları işaret edebilmelisiniz. K-Ortalamaları (ve diğer temel algoritmaları) okuduğunuzdan ve algoritmanın nasıl çalıştığını anladığınızdan emin olun.

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)

Son Düşünceler

NumPy ile mülakat bilginizi geliştirmek, veri bilimi kariyerinde başarıya giden kritik adımlardan biridir. 

Önce temelleri pratik ederek ve anlayarak başlayın; ardından belirli uygulamalara geçin. NumPy’yi ne kadar çok kullanırsanız işlevlerini o kadar iyi anlarsınız ve içselleştirirsiniz. DataCamp’teki şu kurs ve eğitimleri deneyin:

• Python NumPy Dizi Eğitimi
• NumPy Cheat Sheet
• NumPy Hızlandırılmış Kurs