Top 20 NumPy-sollicitatievragen: van basis tot gevorderd

Gemiddelde NumPy-sollicitatievragen

Deze vragen gaan dieper in op het daadwerkelijke gebruik van NumPy. Zodra je een fundamenteel begrip van NumPy-arrays hebt opgebouwd, moet je de functionaliteit verkennen. Het uitvoeren van berekeningen met NumPy mag je op gemiddeld niveau verwachten.

6. Hoe maak je een array met alleen nullen of alleen enen?

Arrays vullen met nullen of enen is een veelvoorkomende behoefte in veel data science-taken, zoals het initialiseren van matrices, het maken van mask-arrays of het opzetten van placeholder-datastructuren. 

Om in NumPy een array met alleen nullen of enen te maken, gebruik je de functies np.zeros() of 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. Wat is broadcasting in NumPy?

Broadcasting is een belangrijk gedrag in NumPy dat efficiënte operaties op arrays van verschillende groottes mogelijk maakt. 

Simpel gezegd, het maakt rekenkundige bewerkingen tussen arrays van verschillende groottes mogelijk door ervoor te zorgen dat beide arrays compatibele vormen hebben. Dit gebeurt wanneer NumPy kleinere arrays automatisch repliqueert over de grotere array zodat ze compatibele vormen hebben. 

Zie het volgende voorbeeld:

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. Hoe vind je het gemiddelde, de mediaan en de standaardafwijking van een NumPy-array?

Het gemiddelde, de mediaan en de standaardafwijking zijn belangrijke beschrijvende statistieken die vaak worden gebruikt om onze data te begrijpen. NumPy berekent deze heel eenvoudig en heeft er speciaal gebouwde functies voor. 

Deze berekeningen kennen is belangrijk om ons vermogen om NumPy te gebruiken te vergroten:

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. Hoe kunnen we NumPy gebruiken om onze numerieke data snel te query'en en acties uit te voeren op basis van een booleaanse voorwaarde?

Hoewel we NumPy's primaire doel zien als een pakket voor berekeningen, heeft het ook krachtige mogelijkheden voor datamanipulatie. 

NumPy kan eenvoudig gegevens opvragen via booleaanse indexering en bewerkingen uitvoeren op basis van resultaten. De methode where() is vooral handig wanneer we wijzigingen in onze data willen aanbrengen op basis van numerieke waarden.

Stel dat we een data frame met examencijfers hebben, df genaamd, en de studenten willen categoriseren. Een eenvoudige np.where() kan er zo uitzien:

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

Merk op dat de methode where() maximaal 3 inputs accepteert: 

• De eerste is de booleaanse voorwaarde van welke aard dan ook
• De tweede is het resultaat als de voorwaarde waar is
• De derde is het resultaat als de voorwaarde onwaar is

10. Wat is een manier om NumPy te gebruiken voor iets als Mean Squared Error?

NumPy's vermogen om in één keer over een hele array te werken maakt het implementeren van berekeningen zoals Mean Squared Error (MSE) simpel. 

Omdat het eenvoudige operaties element voor element uitvoert, vectoriseert het de bewerking gemakkelijk en biedt het een efficiënte manier om MSE te berekenen. 

Een voorbeeld van een implementatie van MSE in NumPy volgt:

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

Gevorderde NumPy-sollicitatievragen

Tijd voor het gevorderde niveau! Op dit niveau wordt verwacht dat je NumPy gebruikt om complexere problemen op te lossen.

11. Hoe kun je rollende statistieken berekenen met NumPy, zoals een rollend gemiddelde?

Rollende statistieken, zoals een voortschrijdend gemiddelde, zijn erg belangrijk in data science. Het rollend gemiddelde wordt vaak gebruikt om ruis in data te dempen, vooral bij tijdsgebonden data. 

Een minder bekende functionaliteit van NumPy is "strides". Een van de manieren waarop stride wordt geïmplementeerd, is door een sliding window-weergave van je array te maken. Met lib.stride_tricks.sliding_window_view() kun je eenvoudig subarrays genereren. 

Je kunt vervolgens allerlei samenvattingen doen, zoals het gemiddelde berekenen, op elk van deze subsets om een rollend gemiddelde te verkrijgen. Hier is een voorbeeldimplementatie:

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. Hoe voer je geavanceerde indexering uit om elementen uit een multidimensionale array te selecteren op basis van een voorwaarde?

Hoewel indexeren een fundamentele vaardigheid voor NumPy is, kunnen geavanceerdere indexeringstechnieken data scientists helpen om hun data preciezer te slicen. 

Door gebruik te maken van integer array-indexering en booleaanse indexering wordt het triviaal om datasets te creëren die aan specifieke criteria voldoen.

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. Hoe kun je NumPy gebruiken om een lineaire-algebrabewerking uit te voeren, zoals matrixdecompositie, of een stelsel lineaire vergelijkingen op te lossen?

Matrixdecompositie uitvoeren is van vitaal belang voor data scientists die met grote hoeveelheden data werken. Data terugbrengen tot de hoofcomponenten is een kritieke eerste stap om complexiteit en ruis te verminderen. 

Het linalg-module van NumPy stelt ons in staat om eenvoudig lineaire algebra uit te voeren om hoofcomponenten te verkrijgen. 

# 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. Hoe kun je het geheugengebruik optimaliseren bij het werken met grote arrays in NumPy?

Een zelden gebruikte functionaliteit van NumPy is memmap(). Hiermee kunnen we arrays als bestand opslaan, waardoor we grotere arrays kunnen lezen dan alleen in het geheugen past. Het belangrijkste voordeel is lui (lazy) gegevenslezen, wat de totale geheugenvraag vermindert terwijl we toch de hele dataset kunnen beoordelen. 

Door deze functie slim te gebruiken, kan een data scientist gemakkelijker en handiger met grote data werken.

​​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. Hoe kun je arrays met ontbrekende of oneindige waarden in NumPy afhandelen en manipuleren?

Omgaan met ontbrekende en oneindige waarden is gebruikelijk voor data scientists. Je wilt mogelijk eerst NumPy's isnan() of isinf() gebruiken om deze ontbrekende en oneindige waarden te vinden. 

Als er een systematisch probleem is, willen we misschien onze pijplijnen beoordelen; anders willen we deze waarden mogelijk opvullen. 

Hoewel we mogelijk niet direct NumPy gebruiken om ontbrekende waarden op te vullen, gebruiken we vaak NumPy-functies in combinatie met iets als pandas fillna() om ontbrekende data op te vullen. Zo willen we bijvoorbeeld NumPy's mean()- of median()-functies gebruiken om foutieve waarden snel op te vullen.

NumPy-sollicitatievragen voor data scientists

Tot nu toe hebben we algemene NumPy-vragen behandeld. Natuurlijk kunnen de eerder besproken vragen van toepassing zijn op data science, maar in dit onderdeel heb ik specifieke NumPy-vragen voor data scientists verzameld.

16. Is er een manier om snel en eenvoudig functies toe te passen op elke rij en kolom van een 2D-array?

Soms moeten we aangepaste berekeningen uitvoeren op onze array om informatie per rij of kolom te krijgen. Gelukkig kan de NumPy-methode apply_along_axis() worden gebruikt om een aangepaste functie toe te passen over een NumPy-array. Deze functies worden toegepast over de gehele lengte van een bepaalde as in elke 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. Hoe kun je NumPy inzetten voor feature scaling en normalisatie van datasets voor machine learning?

Normalisatie van data zorgt ervoor dat we onze machinelearningmodellen goed trainen. Zonder normalisatie kan de schaal onze modelresultaten beïnvloeden, vooral bij afstands gebaseerde modellen. 

We kunnen de functies van NumPy gebruiken om eenvoudig te schalen. Hier is een voorbeeld van min-max-scaling dat voor alle rijen draait. Zorg dat je de juiste dimensie kiest bij 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. Wat zijn enkele manieren waarop we onze NumPy-arrays eenvoudig kunnen sorteren en indexeren?

Hoewel we in een DataFrame iets als sort_values() hebben, zijn er gevallen waarin we de locatie van deze gesorteerde waarden willen vinden. 

NumPy's argsort() levert de posities die een gegeven array zouden sorteren. Een nuttig scenario is wanneer we andere datasets correct willen indexeren om overeen te komen met onze gesorteerde arrays. Door de posities paraat te hebben, kunnen we de output van argsort() gebruiken om consistentie over onze datasets te waarborgen.

19. Wat is een belangrijk aspect van NumPy's generator voor willekeurige getallen dat je kunt gebruiken om hem voorspelbaar te maken en waarom?

Generatoren voor willekeurige getallen in de informatica zijn niet echt willekeurig. Ze zijn gebaseerd op een initiële seed. Omdat we onze data vaak willen testen en resultaten gemakkelijk willen beoordelen, moeten we de hoeveelheid willekeurigheid in onze pijplijn minimaliseren. 

Door de methode random.seed() van NumPy te gebruiken, kunnen we de seed instellen voor een hele pijplijn, zodat we elke keer vergelijkbare resultaten krijgen. Een specifieke seed instellen stelt ons in staat te beoordelen of verbeteringen in onze resultaten zijn gebaseerd op onze modelaanpassingen en niet op willekeur.

20. Beschrijf hoe je K-Means in NumPy zou kunnen implementeren.

Tijdens een sollicitatie kun je gevraagd worden om een of ander algoritme te implementeren. Bij dit soort vragen draait het erom dat je een fundamenteel begrip van het model en het pakket laat zien. 

Je hoeft niet elke coderegel hieronder te onthouden, maar je moet de belangrijkste stappen en methoden kunnen aanwijzen. Zorg dat je K-Means (en andere basisalgoritmen) hebt gelezen en begrijpt hoe het algoritme werkt.

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)

Tot slot

Je kennis van NumPy voor sollicitaties opbouwen is een van de kritieke stappen naar succes in een carrière in data science. 

Begin met oefenen en het begrijpen van de basisprincipes, gevolgd door specifieke implementatie. Hoe meer je NumPy gebruikt, hoe beter je de functies begrijpt en internaliseert. Probeer enkele cursussen en tutorials op DataCamp, zoals de volgende:

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