Fondamenti di NumPy: array e operazioni matematiche
Creerà e manipolerà array NumPy, eseguirà operazioni aritmetiche vettorializzate e comprenderà il broadcasting per gestire i dati numerici in modo efficiente.
Fondamenti di NumPy: array e operazioni matematiche è una lezione Machine Learning Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Machine Learning Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Machine Learning Academy include 4 lezioni in totale.
Perché NumPy è alla base del ML
NumPy è alla base di ogni libreria di ML. Il suo punto di forza è la matematica vettorializzata: opera su interi array contemporaneamente usando codice C veloce, lasciando indietro i cicli Python.
import numpy as np
import time
# Speed comparison: NumPy vs Python list
n = 1_000_000
python_list = list(range(n))
np_array = np.arange(n)
# Python loop (slow)
start = time.time()
result = [x * 2 for x in python_list]
print(f'Python loop: {time.time() - start:.3f}s')
# NumPy vectorised (fast)
start = time.time()
result = np_array * 2
print(f'NumPy vectorised: {time.time() - start:.4f}s')Creare array NumPy
L'oggetto fondamentale di NumPy è l'array. La sua caratteristica più importante è la shape, una tupla che indica la dimensione di ciascun asse, ad esempio (righe, colonne). Il codice mostra come crearli.
import numpy as np
# From Python list
a = np.array([1, 2, 3, 4, 5])
print('1D array:', a, '| shape:', a.shape) # (5,)
# 2D matrix from nested list
M = np.array([[1, 2, 3], [4, 5, 6]])
print('2D matrix shape:', M.shape) # (2, 3)
# Built-in generators
zeros = np.zeros((3, 4)) # 3x4 matrix of zeros
ones = np.ones((2, 5)) # 2x5 matrix of ones
range_arr = np.arange(0, 10, 2) # [0 2 4 6 8]
linspace = np.linspace(0, 1, 5) # 5 evenly spaced points
random = np.random.randn(3, 3) # 3x3 standard normalIndicizzazione e slicing degli array
Si accede agli array usando [riga, colonna] e si esegue lo slicing con start:stop:step. Attenzione: uno slice è una vista, non una copia; modificarlo significa modificare anche l'originale. Per sicurezza, usi .copy().
import numpy as np
M = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
# Single element
print(M[1, 2]) # 7 (row 1, column 2)
# Slice rows and columns
print(M[0:2, 1:3]) # rows 0-1, columns 1-2 -> [[2,3],[6,7]]
# All rows, last column
print(M[:, -1]) # [4, 8, 12]
# Boolean indexing
print(M[M > 6]) # [7, 8, 9, 10, 11, 12]Operazioni aritmetiche vettorializzate
Per impostazione predefinita, la matematica di NumPy è element-wise: a + b somma gli elementi corrispondenti senza alcun ciclo. Viene eseguita in C compilato, per questo è velocissima anche su milioni di numeri. Osservi il codice.
import numpy as np
a = np.array([1.0, 2.0, 3.0, 4.0])
b = np.array([10.0, 20.0, 30.0, 40.0])
print('Addition:', a + b) # [11. 22. 33. 44.]
print('Multiply:', a * b) # [10. 40. 90. 160.]
print('Power:', a ** 2) # [ 1. 4. 9. 16.]
print('Divide:', b / a) # [10. 10. 10. 10.]
# Scalar operations apply to all elements
print('Add scalar:', a + 100) # [101. 102. 103. 104.]
print('Square root:', np.sqrt(a)) # [1. 1.41 1.73 2.]Broadcasting: operare su shape diverse
Il broadcasting consente a NumPy di combinare shape diverse, estendendo quella più piccola per adattarla. È il modo in cui si aggiunge un vettore di bias a un intero batch senza scrivere cicli.
import numpy as np
# Matrix + vector (broadcasting)
matrix = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]) # shape (3, 3)
bias = np.array([10, 20, 30]) # shape (3,) -> broadcasts to (3, 3)
result = matrix + bias
print(result)
# [[11 22 33]
# [14 25 36]
# [17 28 39]]
# Normalize each column to zero mean (ML preprocessing)
mean = matrix.mean(axis=0) # shape (3,)
centered = matrix - mean # broadcasts across rowsFunzioni di aggregazione
Le aggregazioni, come la media e la somma, riducono un array. axis indica la direzione: axis=0 procede lungo le colonne, axis=1 lungo le righe. Il codice mostra entrambi i casi.
import numpy as np
X = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]], dtype=float)
print('Global mean:', X.mean()) # 5.0
print('Column means:', X.mean(axis=0)) # [4. 5. 6.]
print('Row means:', X.mean(axis=1)) # [2. 5. 8.]
print('Global std:', X.std()) # ~2.58
print('Column max:', X.max(axis=0)) # [7. 8. 9.]
print('Row sum:', X.sum(axis=1)) # [ 6. 15. 24.]Moltiplicazione tra matrici: il cuore del ML
La moltiplicazione tra matrici è il cuore del ML: ogni livello di una rete neurale e ogni previsione ne eseguono una. Usi @, non *, che opera elemento per elemento. Le dimensioni interne devono coincidere: (m,k) per (k,n).
import numpy as np
# Linear regression prediction: y_hat = X @ weights + bias
X = np.random.randn(100, 5) # 100 samples, 5 features
weights = np.random.randn(5) # one weight per feature
bias = 0.5
y_hat = X @ weights + bias # shape: (100,)
print('Predictions shape:', y_hat.shape)
# Matrix-matrix multiplication (e.g., two weight layers)
A = np.random.randn(4, 3) # (4, 3)
B = np.random.randn(3, 5) # (3, 5)
C = A @ B # (4, 5)
print('A @ B shape:', C.shape)Ridimensionare e concatenare gli array
Il ridimensionamento modifica la shape di un array senza toccare i dati, come trasformare un'immagine 28x28 in 784 numeri. La concatenazione con vstack o hstack unisce gli array.
import numpy as np
# Reshape: 1D to 2D
a = np.arange(12) # [0, 1, ..., 11]
matrix = a.reshape(3, 4) # shape (3, 4)
print('Reshaped:', matrix.shape)
# Use -1 to infer one dimension automatically
flat = matrix.reshape(-1) # back to 1D (12,)
row = matrix.reshape(1, -1) # shape (1, 12)
col = matrix.reshape(-1, 1) # shape (12, 1)
# Stack two arrays row-wise
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
stacked = np.vstack([A, B]) # shape (4, 2)Generazione di numeri casuali per il ML
I numeri casuali sono alla base dell'inizializzazione dei pesi, del mescolamento e della suddivisione tra training e test. Imposti sempre un seed per ottenere risultati ripetibili: senza di esso, ogni esecuzione è diversa e il debug diventa complicato.
import numpy as np
# Set seed for reproducibility
rng = np.random.default_rng(seed=42)
# Common distributions used in ML
uniform = rng.uniform(0, 1, size=(3, 3)) # Uniform [0, 1)
normal = rng.normal(0, 1, size=(3, 3)) # Standard normal
integers = rng.integers(0, 10, size=5) # Random integers
# Shuffle an array
data = np.arange(10)
rng.shuffle(data)
print('Shuffled:', data)
# Random sampling without replacement
idxs = rng.choice(100, size=20, replace=False) # 20 unique indicesMaschere booleane e indicizzazione avanzata
Il mascheramento booleano filtra gli array in un'unica riga chiara: si confrontano i valori con una condizione e poi si selezionano le corrispondenze. L'indicizzazione avanzata seleziona gli elementi tramite un elenco esplicito di posizioni.
import numpy as np
scores = np.array([85, 42, 91, 67, 55, 78, 33, 95])
# Boolean mask: select scores above 70
mask = scores > 70
print('Mask:', mask) # [T F T F F T F T]
print('High scores:', scores[mask]) # [85 91 78 95]
# Count how many passed
print('Passed:', mask.sum()) # 4
# Fancy indexing: select by explicit indices
indices = np.array([0, 2, 7])
print('Selected:', scores[indices]) # [85 91 95]
# Replace outliers
scores[scores < 50] = 50 # clip low scores to 50NumPy nei flussi di lavoro con scikit-learn
scikit-learn richiede shape corrette: X deve essere 2D (campioni, caratteristiche), mentre y deve essere 1D (campioni). Una shape come (100,) invece di (100, 1) è un errore comune: reshape(-1, 1) lo risolve.
import numpy as np
from sklearn.linear_model import LinearRegression
# X must be 2D: (n_samples, n_features)
X = np.array([1, 2, 3, 4, 5]) # shape (5,) -- WRONG
# Fix:
X = X.reshape(-1, 1) # shape (5, 1) -- CORRECT
y = np.array([2.1, 4.0, 5.9, 8.1, 10.0]) # shape (5,) -- correct
model = LinearRegression()
model.fit(X, y)
print('Learned slope:', round(model.coef_[0], 2)) # ~2.0Verifica rapida
Verifichi la Sua comprensione dei concetti di Machine Learning con Python presentati in questa lezione.
Riepilogo della lezione
Ha appreso i fondamenti di NumPy: gli array sono alla base di tutto il ML, la matematica vettorializzata e il broadcasting eliminano i cicli lenti e l'operatore @ viene usato da ogni modello. Prossimo argomento: Pandas. 🐼
Impara Python con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 30
- Lezioni
- 120
Domande Frequenti
La lezione «Fondamenti di NumPy: array e operazioni matematiche» è gratuita?
Sì — il testo completo di «Fondamenti di NumPy: array e operazioni matematiche» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Machine Learning Academy, passa a CoddyKit PRO. Il corso Machine Learning Academy include 4 lezioni in totale.
Cosa imparerò in «Fondamenti di NumPy: array e operazioni matematiche»?
Creerà e manipolerà array NumPy, eseguirà operazioni aritmetiche vettorializzate e comprenderà il broadcasting per gestire i dati numerici in modo efficiente. Eserciti Machine Learning Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Machine Learning Academy?
Non è richiesta alcuna esperienza precedente. Machine Learning Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Fondamenti di NumPy: array e operazioni matematiche»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Machine Learning Academy?
Sì. Ogni lezione Machine Learning Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Installazione di Anaconda e Jupyter Notebook
- Fondamenti di NumPy: array e operazioni matematiche
- Pandas per la manipolazione dei dati
- Visualizzazione dei dati con Matplotlib e Seaborn