Top 20 întrebări pentru interviu despre NumPy: de la bază la avansat

Întrebări intermediare pentru interviu despre NumPy

Aceste întrebări intră mai adânc în utilizarea efectivă a lui NumPy. După ce ai stabilit o înțelegere fundamentală a arrays-urilor NumPy, ar trebui să-i explorezi funcționalitatea. La nivel intermediar, este de așteptat să efectuezi calcule cu NumPy.

6. Cum creezi un array plin cu zerouri sau cu uniți?

Crearea de arrays umplute cu zerouri sau uniți este o cerință comună în multe sarcini de data science, cum ar fi inițializarea matricilor, crearea de arrays mască sau pregătirea structurilor de date placeholder. 

Pentru a crea un array numai cu zerouri sau numai cu uniți în NumPy, folosești funcțiile np.zeros() sau 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. Ce este broadcasting în NumPy?

Broadcasting este un comportament-cheie în NumPy care permite operații eficiente pe arrays de dimensiuni diferite. 

Pe scurt, permite operații aritmetice între arrays de dimensiuni diferite, asigurând compatibilitatea formelor. Acest lucru se întâmplă când NumPy replică automat arrays-urile mai mici peste array-ul mai mare astfel încât să aibă forme compatibile. 

Vezi exemplul următor:

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. Cum găsești media, mediana și deviația standard ale unui array NumPy?

Media, mediana și deviația standard sunt statistici descriptive esențiale folosite frecvent pentru a ne înțelege datele. NumPy le calculează foarte ușor și are funcții special construite pentru ele. 

Cunoașterea acestor calcule este importantă pentru a ne crește capacitatea de a utiliza 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. Cum putem folosi NumPy pentru a interoga rapid datele numerice și a efectua acțiuni pe baza unei expresii booleene?

Deși ne gândim la scopul principal al lui NumPy ca fiind calculele, are și capacități puternice de manipulare a datelor. 

NumPy poate interoga ușor datele prin indexare booleană și poate efectua operații pe baza rezultatelor. Metoda where() este deosebit de utilă când vrem să facem modificări în date pe baza valorilor numerice.

Presupune că avem un data frame cu note la examene numit df și vrem să categorizăm studenții. Un np.where() simplu ar putea arăta astfel:

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

Reține că metoda where() primește până la 3 intrări: 

• Prima este expresia booleană de orice fel
• A doua este rezultatul dacă este adevărat
• A treia este rezultatul dacă este fals

10. Care este o modalitate de a utiliza NumPy pentru ceva precum Mean Squared Error?

Capacitatea lui NumPy de a lucra pe întregul array dintr-o dată face implementarea calculelor precum Mean Squared Error (MSE) simplă. 

Pentru că efectuează operații simple pe bază de element, vectorizează ușor operația și oferă o modalitate eficientă de a calcula MSE. 

Un exemplu de implementare a MSE în NumPy urmează:

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

Întrebări avansate pentru interviu despre NumPy

Acum intrăm în teritoriu avansat! La acest nivel, este de așteptat să folosești NumPy pentru a rezolva probleme mai complexe.

11. Cum poți calcula statistici rulante în NumPy, cum ar fi media rulantă?

Statisticile rulante, precum media rulantă, sunt foarte importante în data science. Media rulantă este folosită adesea pentru a netezi datele zgomotoase, mai ales dacă sunt bazate pe timp. 

O funcționalitate mai puțin cunoscută a lui NumPy este „strides”. Unul dintre modurile în care este implementat stride este crearea unei vizualizări cu fereastră glisantă a array-ului. Folosind lib.stride_tricks.sliding_window_view(), poți genera ușor subseturi de array. 

Apoi poți face orice fel de sumarizare, cum ar fi calcularea mediei, pe fiecare dintre aceste subseturi pentru a obține o medie rulantă. Iată un exemplu de implementare:

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. Cum efectuezi indexare avansată pentru a selecta elemente dintr-un array multidimensional pe baza unei condiții?

Deși indexarea poate fi o abilitate fundamentală pentru NumPy, utilizarea unor tehnici mai avansate de indexare le permite data scientist-ilor să-și felieze datele mai precis. 

Prin utilizarea indexării cu array-uri de întregi și indexării booleene, crearea de seturi de date care îndeplinesc criterii specifice devine banală.

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. Cum poți folosi NumPy pentru a realiza o operație de algebră liniară, cum ar fi o descompunere matricială sau rezolvarea unui sistem de ecuații liniare?

Realizarea descompunerilor matriciale este vitală pentru data scientist-ii care se ocupă de volume mari de date. Reducerea datelor la componentele principale este un prim pas esențial în reducerea complexității și a zgomotului. 

Modulul linalg al lui NumPy ne permite să efectuăm cu ușurință algebră liniară pentru a obține componentele principale. 

# 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. Cum poți optimiza utilizarea memoriei când lucrezi cu arrays mari în NumPy?

O funcționalitate rar folosită în NumPy este memmap(). Aceasta ne permite să stocăm arrays ca fișier, ceea ce ne permite să citim arrays mai mari decât am putea ține doar în memorie. Principalul său beneficiu este citirea leneșă a datelor, care reduce nevoia totală de memorie și totuși ne permite să evaluăm întregul set de date. 

Folosirea inteligentă a acestei funcții va permite unui data scientist să lucreze cu date mari mai ușor și mai comod.

​​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. Cum poți gestiona și manipula arrays cu valori lipsă sau infinite în NumPy?

Gestionarea valorilor lipsă și infinite este ceva obișnuit pentru data scientist-i. Mai întâi, ai putea folosi isnan() sau isinf() din NumPy pentru a găsi aceste valori lipsă și infinite. 

Dacă există o problemă sistematică, am putea dori să ne evaluăm pipeline-urile; altfel, am putea dori să completăm aceste valori. 

Deși s-ar putea să nu folosim direct NumPy pentru a completa valorile lipsă, folosim adesea funcții NumPy în combinație cu ceva precum fillna() din pandas pentru a completa datele lipsă. De exemplu, am putea dori să folosim funcțiile mean() sau median() din NumPy pentru a completa rapid valorile eronate.

Întrebări despre NumPy pentru data scientists

Până acum am acoperit întrebări generale despre NumPy. Desigur, întrebările anterioare se pot aplica la data science, dar în această secțiune am compilat întrebări specifice despre NumPy pentru data scientists.

16. Există o modalitate rapidă și ușoară de a aplica funcții fiecărei linii și fiecărei coloane dintr-un array 2D?

Uneori, trebuie să efectuăm calcule personalizate pe array pentru a obține informații pentru fiecare rând sau coloană. Din fericire, metoda NumPy apply_along_axis() poate fi folosită pentru a aplica o funcție personalizată pe un array NumPy. Aceste funcții sunt aplicate pe întregul unei anumite axe din fiecare array. 

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. Cum poți folosi NumPy pentru scalarea caracteristicilor și normalizarea seturilor de date pentru machine learning?

Normalizarea datelor asigură că ne antrenăm corect modelele de machine learning. Fără normalizare, scara poate influența rezultatele modelului, mai ales pentru modelele bazate pe distanță. 

Putem folosi funcțiile NumPy pentru a efectua ușor scalarea. Iată un exemplu de scalare min-max care rulează pentru toate rândurile. Asigură-te că alegi dimensiunea corectă atunci când faci 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. Care sunt câteva moduri prin care putem sorta și indexa ușor arrays-urile NumPy?

Deși avem, de exemplu, sort_values() pentru DataFrame, există situații în care vrem să găsim poziția acestor valori sortate. 

Funcția argsort() din NumPy oferă pozițiile care ar ordona un array dat. Un scenariu util este când trebuie să indexăm corect alte seturi de date pentru a se potrivi cu arrays-urile noastre sortate. Având pozițiile gata, putem folosi ieșirea din argsort() pentru a asigura consistența între seturile noastre de date.

19. Care este un aspect important al generatorului de numere aleatoare din NumPy care poate fi folosit pentru a-l face predictibil și de ce?

Generatoarele de numere aleatoare în calcul nu sunt cu adevărat aleatoare. Ele se bazează pe un seed inițial. Deoarece vrem adesea să testăm datele și să putem evalua ușor rezultatele, trebuie să minimizăm cantitatea de aleatoriu prezentă în pipeline-ul nostru. 

Folosind metoda random.seed() din NumPy, putem seta seed-ul pentru întregul pipeline astfel încât să obținem rezultate similare de fiecare dată. Setarea unui seed specific ne permite să evaluăm dacă îmbunătățirile rezultatelor se bazează pe ajustările modelului nostru și nu pe aleatoriu.

20. Descrie cum ai putea implementa K-Means în NumPy.

În timpul unui interviu, ți se poate cere să implementezi un anumit algoritm. Accentul acestor întrebări este să răspunzi cu o înțelegere fundamentală a modelului și a bibliotecii. 

Nu este nevoie să memorezi fiecare linie de cod de mai jos, dar fii capabil să evidențiezi pașii și metodele cheie necesare. Asigură-te că ai citit despre K-Means (și alte algoritmi de bază) și că înțelegi și modul în care funcționează algoritmul.

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)

Gânduri finale

Construirea cunoștințelor pentru interviu cu NumPy este unul dintre pașii critici către succes într-o carieră în data science. 

Începe prin a practica și a înțelege fundamentele, apoi implementarea specifică. Cu cât folosești mai mult Numpy, cu atât vei înțelege și internaliza mai bine funcțiile sale. Încearcă câteva dintre cursurile și tutorialele de pe DataCamp, precum următoarele:

• Tutorial Python Numpy Array
• Fișă de referință Numpy
• Curs intensiv Numpy