0Pricing
Pandas & NumPy Academy · Lezione

Determinanti, inverse e trasposte

Calcoli i determinanti delle matrici con np.linalg.det, le inverse con np.linalg.inv e le trasposte con .T.

Determinanti, inverse e trasposte è una lezione Pandas & NumPy 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 Pandas & NumPy Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

La trasposta di una matrice

La trasposta di una matrice la riflette rispetto alla diagonale: le righe diventano colonne e le colonne diventano righe. Se A ha forma (m, n), allora A.T ha forma (n, m). Le trasposte compaiono ovunque nell'algebra lineare: nel calcolo delle matrici di covarianza, nell'implementazione della retropropagazione del gradiente e nella conversione tra le convenzioni dei vettori riga e dei vettori colonna. NumPy accede alla trasposta tramite l'attributo .T: non viene effettuata alcuna copia, ma si ottiene semplicemente una vista con gli stride riordinati.

import numpy as np

A = np.array([[1, 2, 3],
              [4, 5, 6]])
print('A shape:', A.shape)       # (2, 3)
print('A.T shape:', A.T.shape)   # (3, 2)
print(A.T)

La trasposta nella pratica

Un'operazione frequente consiste nel calcolare A.T @ A, che produce una matrice quadrata simmetrica utilizzata nella regressione ai minimi quadrati, nella PCA e nelle equazioni normali. Se A ha forma (n, p), allora A.T @ A ha forma (p, p). Il risultato è sempre simmetrico perché (A.T @ A)[i,j] == (A.T @ A)[j,i]. Molti risolutori numerici sfruttano questa proprietà per aumentare l'efficienza.

import numpy as np

A = np.array([[1.0, 2.0],
              [3.0, 4.0],
              [5.0, 6.0]])  # shape (3, 2)

ATA = A.T @ A   # shape (2, 2), symmetric
print('A.T @ A:')
print(ATA)
print('Is symmetric:', np.allclose(ATA, ATA.T))

Il determinante: significato

Il determinante di una matrice quadrata è un valore scalare che contiene informazioni geometriche: misura il fattore con cui la matrice scala le aree (in 2D) o i volumi (in dimensioni superiori). Un determinante uguale a zero indica che la matrice è singolare: comprime lo spazio in un sottospazio di dimensione inferiore e non ha inversa. Un determinante diverso da zero garantisce che la matrice sia invertibile. NumPy lo calcola con np.linalg.det().

import numpy as np

# Non-singular matrix
A = np.array([[3.0, 1.0],
              [2.0, 4.0]])
print('det(A):', np.linalg.det(A))   # 3*4 - 1*2 = 10

# Singular matrix (row 2 = 2 * row 1)
B = np.array([[1.0, 2.0],
              [2.0, 4.0]])
print('det(B):', np.linalg.det(B))   # ~0

Calcolare l'inversa con np.linalg.inv()

L'inversa di una matrice A, indicata con A⁻¹, soddisfa A @ A⁻¹ = I, dove I è la matrice identità. Le inverse esistono solo per matrici quadrate e non singolari. np.linalg.inv(A) calcola numericamente l'inversa. Nella pratica, dovrebbe calcolare esplicitamente le inverse solo raramente, perché questa operazione è numericamente instabile; per i sistemi di equazioni, preferisca invece np.linalg.solve(). Tuttavia, comprendere concettualmente le inverse è fondamentale.

import numpy as np

A = np.array([[3.0, 1.0],
              [2.0, 4.0]])

A_inv = np.linalg.inv(A)
print('Inverse:')
print(A_inv)

# Verify: A @ A_inv should be identity
I = A @ A_inv
print('A @ A_inv (should be I):')
print(np.round(I, 10))

Instabilità numerica dell'inversione diretta

Calcolare l'inversa di una matrice e poi moltiplicarla introduce errori di arrotondamento che si accumulano. Ad esempio, risolvere A_inv @ b è meno preciso che chiamare direttamente np.linalg.solve(A, b). Una matrice ben condizionata (con determinante lontano da zero) è meno sensibile a questi errori. Il numero di condizionamento (np.linalg.cond(A)) quantifica quanto una matrice sia vicina a essere singolare: numeri di condizionamento elevati segnalano problemi numerici.

import numpy as np

A = np.array([[1.0, 2.0],
              [1.0001, 2.0]])
print('Condition number:', np.linalg.cond(A))
# Very high condition number -> near-singular, unstable inversion

b = np.array([3.0, 3.0001])
# Prefer solve over inv @ b
print('Solution via solve:', np.linalg.solve(A, b))

Matrici ortogonali e relative trasposte

Una classe speciale di matrici è costituita dalle matrici ortogonali, per le quali vale A.T @ A = I. Ciò significa che la trasposta È l'inversa, rendendo le matrici ortogonali estremamente economiche da invertire. Le matrici di rotazione e il fattore Q della decomposizione QR sono ortogonali. Le colonne di una matrice ortogonale formano una base ortonormale: ogni colonna ha lunghezza unitaria ed è perpendicolare a tutte le altre colonne.

import numpy as np

# 90-degree rotation matrix is orthogonal
theta = np.pi / 2
R = np.array([[np.cos(theta), -np.sin(theta)],
              [np.sin(theta),  np.cos(theta)]])

print('R.T @ R (should be identity):')
print(np.round(R.T @ R, 10))
print('Is orthogonal:', np.allclose(R.T @ R, np.eye(2)))

La pseudoinversa per le matrici non quadrate

Un'inversa ordinaria esiste solo per le matrici quadrate, ma la pseudoinversa di Moore-Penrose generalizza l'inversione a qualsiasi matrice. np.linalg.pinv(A) la calcola usando la SVD. È alla base della soluzione ai minimi quadrati dei sistemi sovradeterminati (con più equazioni che incognite), esattamente ciò che risolve la regressione lineare. Se A è quadrata e invertibile, pinv(A) è uguale a inv(A).

import numpy as np

# Over-determined system: 3 equations, 2 unknowns
A = np.array([[1.0, 1.0],
              [1.0, 2.0],
              [1.0, 3.0]])
b = np.array([2.0, 3.0, 5.0])

# Least-squares solution using pseudo-inverse
x = np.linalg.pinv(A) @ b
print('Best-fit solution:', x)
# Or use lstsq directly
x2, _, _, _ = np.linalg.lstsq(A, b, rcond=None)
print('lstsq solution:', x2)

Segno del determinante e ridimensionamento del volume

Il segno del determinante indica se la trasformazione conserva o inverte l'orientamento. Un determinante positivo significa che l'orientamento è conservato (come in una rotazione); un determinante negativo significa che l'orientamento è invertito (come in una riflessione). Il valore assoluto fornisce il fattore di ridimensionamento del volume. Per una matrice 2×2 [[a,b],[c,d]], det = a*d - b*c. NumPy gestisce in modo efficiente matrici quadrate di qualsiasi dimensione.

import numpy as np

# Identity: det = 1 (no scaling, no flip)
I = np.eye(3)
print('det(I):', np.linalg.det(I))    # 1.0

# Scaling by 2 in all directions: det = 8 = 2^3
S = 2 * np.eye(3)
print('det(2I):', np.linalg.det(S))   # 8.0

# Reflection: det = -1
F = np.array([[-1.0, 0.0],
              [ 0.0, 1.0]])
print('det(reflection):', np.linalg.det(F))

Usare np.linalg.slogdet() per una maggiore stabilità

Per le matrici di grandi dimensioni, il determinante può produrre un overflow oppure ridursi a zero per underflow anche quando la matrice non è singolare. np.linalg.slogdet(A) restituisce (sign, log_abs_det): il segno e il logaritmo naturale del determinante in valore assoluto, evitando così l'overflow numerico. Questa tecnica è ampiamente usata nei modelli probabilistici (come le verosimiglianze gaussiane), in cui si lavora nello spazio logaritmico per mantenere i numeri gestibili.

import numpy as np

A = np.random.rand(100, 100)

# Direct det might underflow for large matrices
sign, logdet = np.linalg.slogdet(A)
print('Sign:', sign)
print('Log|det|:', logdet)
print('Actual det (may be ~0 due to float):', np.linalg.det(A))
print('Reconstructed |det|:', np.exp(logdet))

Nella pratica: risolvere una matrice 2x2 a mano e con NumPy

Per una matrice 2×2 [[a, b], [c, d]], l'inversa è (1/det) * [[d, -b], [-c, a]], dove det = ad - bc. Conoscere questa formula aiuta a verificare rapidamente il risultato di NumPy. Per matrici più grandi, calcolare analiticamente l'inversa è impraticabile: è proprio per questo che si usa np.linalg.inv(). Verifichi sempre i risultati numerici con np.allclose(A @ A_inv, np.eye(n)).

import numpy as np

a, b, c, d = 3.0, 1.0, 2.0, 4.0
A = np.array([[a, b], [c, d]])
det = a*d - b*c

# Manual inverse
A_inv_manual = (1/det) * np.array([[d, -b], [-c, a]])
print('Manual inv:')
print(A_inv_manual)

# NumPy inverse
print('np.linalg.inv:')
print(np.linalg.inv(A))
print('Match:', np.allclose(A_inv_manual, np.linalg.inv(A)))

Combinare trasposta e inversa nelle pipeline

Un modello comune dell'algebra lineare combina trasposta e inversa: calcolare (A.T @ A)⁻¹ @ A.T produce la matrice di proiezione usata nei minimi quadrati ordinari. In NumPy, si può scrivere np.linalg.inv(A.T @ A) @ A.T, ma anche in questo caso np.linalg.lstsq è preferibile dal punto di vista numerico. Conoscere il modello sottostante aiuta a capire cosa fa il risolutore e a eseguire il debug dei problemi quando le matrici sono quasi singolari.

import numpy as np

# Design matrix for simple linear regression (with bias)
X = np.column_stack([np.ones(5), np.array([1., 2., 3., 4., 5.])])
y = np.array([2.1, 3.9, 6.2, 8.1, 9.8])

# OLS via normal equations: beta = (X.T @ X)^-1 @ X.T @ y
beta = np.linalg.inv(X.T @ X) @ X.T @ y
print('Coefficients (intercept, slope):', np.round(beta, 3))

# Verify with lstsq
beta2, _, _, _ = np.linalg.lstsq(X, y, rcond=None)
print('lstsq result:', np.round(beta2, 3))

Verifica rapida

Verifichi la sua comprensione dei concetti di analisi dei dati presentati in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato che: A.T è la trasposta che scambia righe e colonne, np.linalg.inv() calcola l'inversa di una matrice, ma dovrebbe essere usata direttamente solo raramente (preferisca solve o lstsq), e np.linalg.det() restituisce il determinante, che è zero per le matrici singolari. Prossimamente esploreremo la risoluzione diretta dei sistemi lineari con np.linalg.solve.

Domande Frequenti

La lezione «Determinanti, inverse e trasposte» è gratuita?

Sì — il testo completo di «Determinanti, inverse e trasposte» è 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 Pandas & NumPy Academy, passa a CoddyKit PRO. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Cosa imparerò in «Determinanti, inverse e trasposte»?

Calcoli i determinanti delle matrici con np.linalg.det, le inverse con np.linalg.inv e le trasposte con .T. Eserciti Pandas & NumPy 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 Pandas & NumPy Academy?

Non è richiesta alcuna esperienza precedente. Pandas & NumPy 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 «Determinanti, inverse e trasposte»?

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 Pandas & NumPy Academy?

Sì. Ogni lezione Pandas & NumPy 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

  1. Moltiplicazione di matrici con np.matmul e @
  2. Determinanti, inverse e trasposte
  3. Risoluzione di sistemi lineari
  4. Panoramica su autovalori e SVD
← Torna a Pandas & NumPy Academy