Le 20 migliori domande su NumPy per i colloqui: dalle basi all’avanzato

Domande intermedie su NumPy per i colloqui

Queste domande vanno più a fondo nell’uso pratico di NumPy. Una volta consolidate le basi sugli array di NumPy, dovresti esplorarne le funzionalità. A livello intermedio ci si aspetta che tu sappia eseguire calcoli con NumPy.

6. Come crei un array di tutti zeri o tutti uno?

Creare array riempiti di zeri o di uno è un’esigenza comune in molte attività di data science, come inizializzare matrici, creare array maschera o predisporre strutture dati segnaposto. 

Per creare un array di soli zeri o soli uno in NumPy, usa le funzioni np.zeros() o np.ones():

import numpy as np

# Crea un array 3x4 di zeri
zeros_arr = np.zeros((3, 4))
print(zeros_arr)
# Output:
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

# Crea un array 2x2 di uno
ones_arr = np.ones((2, 2))
print(ones_arr)
# Output:
# [[1. 1.]
#  [1. 1.]]

7. Che cos’è il broadcasting in NumPy?

Il broadcasting è un comportamento chiave di NumPy che consente operazioni efficienti su array di dimensioni diverse. 

In poche parole, permette operazioni aritmetiche tra array di dimensioni diverse assicurando che abbiano forme compatibili. Ciò avviene quando NumPy replica automaticamente gli array più piccoli sull’array più grande in modo da renderne le forme compatibili. 

Vedi il seguente esempio:

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. Come trovi media, mediana e deviazione standard di un array NumPy?

Media, mediana e deviazione standard sono statistiche descrittive fondamentali per comprendere i dati. NumPy le calcola con facilità e dispone di funzioni dedicate. 

Conoscere questi calcoli è importante per sfruttare al meglio NumPy:

import numpy as np

arr = np.array([1, 2, 3, 4, 5])

# Media
mean_value = np.mean(arr)
print("Mean:", mean_value)  # Output: 3.0

# Mediana
median_value = np.median(arr)
print("Median:", median_value)  # Output: 3.0

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

9. Come possiamo usare NumPy per interrogare rapidamente i dati numerici ed eseguire azioni basate su un’espressione booleana?

Sebbene pensiamo a NumPy principalmente come a un pacchetto di calcolo, ha anche potenti capacità di gestione dei dati. 

NumPy può interrogare facilmente i dati tramite indicizzazione booleana ed eseguire operazioni basate sui risultati. Il metodo where() è particolarmente utile quando vogliamo apportare modifiche ai dati in base ai valori numerici.

Supponiamo di avere un data frame di voti d’esame chiamato df e di voler categorizzare gli studenti. Un semplice np.where() potrebbe essere:

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

Nota che il metodo where() accetta fino a 3 input: 

• Il primo è un’espressione booleana di qualsiasi tipo
• Il secondo è il risultato se l’espressione è vera
• Il terzo è il risultato se l’espressione è falsa

10. In che modo possiamo usare NumPy per qualcosa come il Mean Squared Error?

La capacità di NumPy di lavorare su un intero array in una volta rende semplice implementare calcoli come il Mean Squared Error (MSE). 

Poiché esegue operazioni semplici su base elemento per elemento, vettorializza facilmente l’operazione e offre un modo efficiente per calcolare l’MSE. 

Ecco un esempio di implementazione dell’MSE in NumPy:

# 1. Abbiamo due array: le nostre predizioni e le etichette reali
# 2. Calcoliamo le differenze al quadrato e le sommiamo
# 3. Dividiamo poi per n, la lunghezza dell'array

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

Domande avanzate su NumPy per i colloqui

Ora entriamo nel territorio avanzato! A questo livello ci si aspetta che tu usi NumPy per risolvere problemi più complessi.

11. Come puoi calcolare statistiche mobili con NumPy, come una media mobile?

Le statistiche mobili, come la media mobile, sono molto importanti in data science. La media mobile è spesso usata per levigare dati rumorosi, soprattutto se basati sul tempo. 

Una funzionalità poco nota di NumPy sono gli “stride”. Uno dei modi in cui lo stride è implementato è creare una vista a finestra scorrevole dell’array. Usando lib.stride_tricks.sliding_window_view() puoi generare facilmente sottoinsiemi di array. 

Puoi quindi effettuare qualsiasi tipo di sintesi, come il calcolo della media, su ciascuno di questi sottoinsiemi per ottenere una media mobile. Ecco un esempio di implementazione:

import numpy as np

from numpy.lib.stride_tricks import sliding_window_view
x = np.arange(6)
v = sliding_window_view(x, 3)
# Questo crea v, un array che contiene sottoarray di lunghezza 3 che riflettono la dimensione della finestra.

12. Come esegui un’indicizzazione avanzata per selezionare elementi da un array multidimensionale in base a una condizione?

Sebbene l’indicizzazione sia una competenza fondamentale in NumPy, sfruttare tecniche avanzate può permettere ai data scientist di sezionare i dati con maggiore precisione. 

Utilizzando l’indicizzazione con array di interi e quella booleana, creare dataset che soddisfano criteri specifici diventa banale.

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]]

# Indicizzazione booleana: seleziona gli elementi maggiori di 30
condition = array > 30
print(condition)  # Output:
# [[False False False False]
#  [False  True  True  True]
#  [ True  True  True  True]]

# Applica la condizione per ottenere gli elementi che soddisfano il criterio
a = array[condition]
print(a)  # Output: [35 40 45 50 55 60 65]

# Indicizzazione con array di interi: seleziona elementi specifici in base a indici di riga e colonna
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]

# Combinare indicizzazione booleana e con interi
# Seleziona elementi dell'array > 30 e appartenenti a indici specifici
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. Come puoi usare NumPy per un’operazione di algebra lineare come una decomposizione di matrici o la risoluzione di un sistema lineare?

Eseguire decomposizioni di matrici è vitale per i data scientist che gestiscono grandi volumi di dati. Ridurre i dati alle loro componenti principali è un primo passo fondamentale per ridurre complessità e rumore. 

Il modulo linalg di NumPy consente di eseguire facilmente operazioni di algebra lineare per ottenere le componenti principali. 

# Il segnale sottostante è un'immagine modulata sinusoidalmente
img = lena() # Da scipy.misc import lena
t = np.arange(100)
time = np.sin(0.1*t)
true= time[:,np.newaxis,np.newaxis] * img[np.newaxis,...]

# Aggiungiamo un po' di rumore
noisy = real + np.random.randn(*true.shape)*255

# Matrice (osservazioni, feature)
M = noisy.reshape(noisy.shape[0],-1)

# La scomposizione ai valori singolari fattorizza la matrice dati così:
#   M = U*S*V.T     (dove '*' è la moltiplicazione di matrici)
# * U e V sono matrici singolari contenenti vettori ortogonali di norma unitaria
# * S è una matrice diagonale con i valori singolari di M - possiamo usarla per calcolare le nostre PC

# Otteniamo i risultati della SVD dalla nostra matrice rumorosa
U, s, Vt = np.linalg.svd(M, full_matrices=False)
# Trasponiamo V per ottenere i vettori delle PC
V = Vt.T

# Le PC sono già ordinate in modo decrescente per valore singolare (cioè per quota di varianza spiegata)
# Se usiamo tutte le PC possiamo ricostruire perfettamente il segnale rumoroso
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. Come puoi ottimizzare l’uso della memoria quando lavori con array di grandi dimensioni in NumPy?

Una funzionalità raramente usata di NumPy è memmap(). Consente di memorizzare gli array come file, permettendo di leggere array più grandi di quelli gestibili interamente in memoria. Il suo principale vantaggio è la lettura lazy dei dati, che riduce il fabbisogno complessivo di memoria pur consentendo di analizzare l’intero dataset. 

Usare con intelligenza questa funzione consente a un data scientist di lavorare con grandi moli di dati in modo più semplice e pratico.

​​import numpy as np

# Crea un array grande e salvalo su file usando memmap
filename = 'large_array.dat'
large_array_shape = (10000, 10000)
dtype = np.float32  # Specifica il tipo di dato dell'array

# Crea un oggetto memmap con la forma e il dtype desiderati
large_array = np.memmap(filename, dtype=dtype, mode='w+', shape=large_array_shape)

# Inizializza l'array con alcuni valori (ad es., riempilo con numeri casuali)
large_array[:] = np.random.rand(*large_array_shape)

# Accedi a una piccola parte dell'array senza caricare l'intero array in memoria
sub_array = large_array[5000:5010, 5000:5010]
print(sub_array)  # Output: una matrice 10x10 con valori float casuali

# Pulizia e assicurarsi che le modifiche siano scritte su disco
del large_array

15. Come puoi gestire e manipolare array con valori mancanti o infiniti in NumPy?

Gestire valori mancanti e infiniti è comune per i data scientist. Per prima cosa, potresti usare isnan() o isinf() di NumPy per individuare questi valori mancanti e infiniti. 

Se c’è un problema sistematico, potremmo voler valutare le nostre pipeline; altrimenti, potremmo voler riempire questi valori. 

Anche se potremmo non usare direttamente NumPy per colmare i valori mancanti, spesso impieghiamo funzioni NumPy in combinazione con, ad esempio, fillna() di pandas per riempire i dati mancanti. Per esempio, potremmo usare le funzioni mean() o median() di NumPy per sostituire rapidamente valori errati.

Domande su NumPy per data scientist

Finora abbiamo coperto domande generali su NumPy. Naturalmente, le domande viste prima possono applicarsi alla data science, ma in questa sezione ho raccolto domande specifiche su NumPy per data scientist.

16. Esiste un modo rapido e semplice per applicare funzioni a ogni riga e colonna di un array 2D?

A volte dobbiamo eseguire calcoli personalizzati sul nostro array per ottenere informazioni su ciascuna riga o colonna. Fortunatamente, il metodo NumPy apply_along_axis() può essere usato per applicare una funzione personalizzata su un array NumPy. Queste funzioni sono applicate lungo un intero asse specifico di ciascun array. 

import numpy as np

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

# Definisci una funzione per calcolare il range di un array 1D
def compute_range(arr):
    return np.max(arr) - np.min(arr)

# Applica la funzione compute_range a ogni riga (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. Come puoi sfruttare NumPy per l’feature scaling e la normalizzazione dei dataset per il machine learning?

La normalizzazione dei dati assicura un corretto training dei modelli di machine learning. Senza normalizzazione, la scala può influenzare i risultati del modello, soprattutto per i modelli basati sulle distanze. 

Possiamo usare le funzioni di NumPy per eseguire facilmente lo scaling. Ecco un esempio di min-max scaling applicato a tutte le righe. Assicurati di scegliere la dimensione corretta quando esegui il 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. In quali modi possiamo ordinare e indicizzare facilmente i nostri array NumPy?

Anche se nei DataFrame esiste sort_values(), in certi casi vogliamo trovare la posizione dei valori ordinati. 

argsort() di NumPy fornisce le posizioni che ordinerebbero un dato array. Uno scenario utile è quando dobbiamo indicizzare correttamente altri dataset per allinearli ai nostri array ordinati. Avendo già le posizioni, possiamo usare l’output di argsort() per garantire coerenza tra i dataset.

19. Qual è un aspetto importante del generatore di numeri casuali di NumPy che si può usare per renderlo prevedibile e perché?

I generatori di numeri casuali in informatica non sono realmente casuali: si basano su un seme iniziale. Poiché spesso vogliamo testare i nostri dati e poter valutare facilmente i risultati, dobbiamo ridurre al minimo la casualità presente nella pipeline. 

Usando il metodo random.seed() di NumPy, possiamo impostare il seme per un’intera pipeline in modo da ottenere risultati simili a ogni esecuzione. Impostare un seme specifico ci permette di valutare se i miglioramenti dei risultati dipendono dagli aggiustamenti del modello e non dalla casualità.

20. Descrivi come potresti implementare K-Means in NumPy.

Durante un colloquio, potrebbero chiederti di implementare un algoritmo. L’obiettivo di queste domande è verificare la comprensione fondamentale del modello e del pacchetto. 

Non devi memorizzare ogni riga di codice qui sotto, ma saper indicare i passaggi e i metodi chiave necessari. Assicurati di aver letto di K-Means (e altri algoritmi di base) e di capire anche come funziona l’algoritmo.

import numpy as np

# Genera un dataset di esempio
np.random.seed(42)  # Per riproducibilità
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: inizializza i centroidi in modo casuale
    num_samples, num_features = X.shape
    centroids = X[np.random.choice(num_samples, k, replace=False)]
    
    for i in range(max_iters):
        # Step 2: assegna i cluster
        distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
        cluster_assignments = np.argmin(distances, axis=1)
        
        # Step 3: aggiorna i centroidi
        new_centroids = np.array([X[cluster_assignments == j].mean(axis=0) for j in range(k)])
        
        # Verifica la convergenza
        if np.all(np.linalg.norm(new_centroids - centroids, axis=1) < tol):
            break
        
        centroids = new_centroids
    
    return centroids, cluster_assignments

# Applica il clustering k-means
k = 3
centroids, cluster_assignments = k_means(data, k)

Considerazioni finali

Consolidare le tue conoscenze per i colloqui con NumPy è uno dei passi critici per avere successo in una carriera nella data science. 

Inizia esercitandoti e comprendendo le basi per poi passare all’implementazione concreta. Più usi NumPy, meglio ne capirai e interiorizzerai le funzioni. Prova alcuni corsi e tutorial su DataCamp, come i seguenti:

• Tutorial sugli array NumPy in Python
• Foglio di riferimento NumPy
• Corso rapido su NumPy